diff options
| author | bors <bors@rust-lang.org> | 2019-11-14 14:11:38 +0000 |
|---|---|---|
| committer | bors <bors@rust-lang.org> | 2019-11-14 14:11:38 +0000 |
| commit | 82cf3a4486bc882207a09bf0d9e2dea4632781aa (patch) | |
| tree | 36152685fe6c0e03e5a834a396f553263086e27d | |
| parent | d63b24ffcc48f44ef09e0369e6516d6f2dec3520 (diff) | |
| parent | b5b2a8984e57260bb91d3327490da74f6fa310db (diff) | |
| download | rust-82cf3a4486bc882207a09bf0d9e2dea4632781aa.tar.gz rust-82cf3a4486bc882207a09bf0d9e2dea4632781aa.zip | |
Auto merge of #66314 - GuillaumeGomez:move-error-codes, r=Centril
Move error codes
Works towards #66210.
r? @Centril
Oh btw, for the ones interested, I used this python script to get all error codes content sorted into one final file:
<details>
```python
from os import listdir
from os.path import isdir, isfile, join
def get_error_codes(error_codes, f_path):
with open(f_path) as f:
short_mode = False
lines = f.read().split("\n")
i = 0
while i < len(lines):
line = lines[i]
if not short_mode and line.startswith("E0") and line.endswith(": r##\""):
error = line
error += "\n"
i += 1
while i < len(lines):
line = lines[i]
error += line
if line.endswith("\"##,"):
break
error += "\n"
i += 1
error_codes["long"].append(error)
elif line == ';':
short_mode = True
elif short_mode is True and len(line) > 0 and line != "}":
error_codes["short"].append(line)
while i + 1 < len(lines):
line = lines[i + 1].strip()
if not line.startswith("//"):
break
parts = line.split("//")
if len(parts) < 2:
break
if parts[1].strip().startswith("E0"):
break
error_codes["short"][-1] += "\n"
error_codes["short"][-1] += lines[i + 1]
i += 1
i += 1
def loop_dirs(error_codes, cur_dir):
for entry in listdir(cur_dir):
f = join(cur_dir, entry)
if isfile(f) and entry == "error_codes.rs":
get_error_codes(error_codes, f)
elif isdir(f) and not entry.startswith("librustc_error_codes"):
loop_dirs(error_codes, f)
def get_error_code(err):
x = err.split(",")
if len(x) < 2:
return err
x = x[0]
if x.strip().startswith("//"):
x = x.split("//")[1].strip()
return x.strip()
def write_into_file(error_codes, f_path):
with open(f_path, "w") as f:
f.write("// Error messages for EXXXX errors. Each message should start and end with a\n")
f.write("// new line, and be wrapped to 80 characters. In vim you can `:set tw=80` and\n")
f.write("// use `gq` to wrap paragraphs. Use `:set tw=0` to disable.\n\n")
f.write("syntax::register_diagnostics! {\n\n")
error_codes["long"].sort()
for i in error_codes["long"]:
f.write(i)
f.write("\n\n")
f.write(";\n")
error_codes["short"] = sorted(error_codes["short"], key=lambda err: get_error_code(err))
for i in error_codes["short"]:
f.write(i)
f.write("\n")
f.write("}\n")
error_codes = {
"long": [],
"short": []
}
loop_dirs(error_codes, "src")
write_into_file(error_codes, "src/librustc_error_codes/src/error_codes.rs")
```
</details>
And to move the error codes into their own files:
<details>
```python
import os
try:
os.mkdir("src/librustc_error_codes/error_codes")
except OSError:
print("Seems like folder already exist, moving on!")
data = ''
with open("src/librustc_error_codes/error_codes.rs") as f:
x = f.read().split('\n')
i = 0
short_part = False
while i < len(x):
line = x[i]
if short_part is False and line.startswith('E0') and line.endswith(': r##"'):
err_code = line.split(':')[0]
i += 1
content = ''
while i < len(x):
if x[i] == '"##,':
break
content += x[i]
content += '\n'
i += 1
f_path = "src/librustc_error_codes/error_codes/{}.md".format(err_code)
with open(f_path, "w") as ff:
ff.write(content)
data += '{}: include_str!("./error_codes/{}.md"),'.format(err_code, err_code)
elif short_part is False and line == ';':
short_part is True
data += ';\n'
else:
data += line
data += '\n'
i += 1
with open("src/librustc_error_codes/error_codes.rs", "w") as f:
f.write(data)
```
</details>
556 files changed, 13256 insertions, 13967 deletions
diff --git a/Cargo.lock b/Cargo.lock index 7c074fb18a6..781184af9a9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3120,6 +3120,7 @@ dependencies = [ "graphviz", "jobserver", "log", + "measureme", "num_cpus", "parking_lot 0.9.0", "polonius-engine", @@ -3127,6 +3128,7 @@ dependencies = [ "rustc-rayon-core 0.3.0", "rustc_apfloat", "rustc_data_structures", + "rustc_error_codes", "rustc_errors", "rustc_fs_util", "rustc_index", @@ -3439,6 +3441,7 @@ dependencies = [ "rustc_apfloat", "rustc_codegen_utils", "rustc_data_structures", + "rustc_error_codes", "rustc_errors", "rustc_fs_util", "rustc_incremental", @@ -3517,6 +3520,10 @@ dependencies = [ ] [[package]] +name = "rustc_error_codes" +version = "0.0.0" + +[[package]] name = "rustc_errors" version = "0.0.0" dependencies = [ @@ -3569,6 +3576,7 @@ dependencies = [ "rustc_codegen_ssa", "rustc_codegen_utils", "rustc_data_structures", + "rustc_error_codes", "rustc_errors", "rustc_incremental", "rustc_lint", @@ -3605,6 +3613,7 @@ dependencies = [ "log", "rustc", "rustc_data_structures", + "rustc_error_codes", "rustc_index", "rustc_target", "syntax", @@ -3650,6 +3659,7 @@ dependencies = [ "memmap", "rustc", "rustc_data_structures", + "rustc_error_codes", "rustc_errors", "rustc_index", "rustc_parse", @@ -3675,6 +3685,7 @@ dependencies = [ "rustc", "rustc_apfloat", "rustc_data_structures", + "rustc_error_codes", "rustc_errors", "rustc_index", "rustc_lexer", @@ -3703,6 +3714,7 @@ dependencies = [ "bitflags", "log", "rustc_data_structures", + "rustc_error_codes", "rustc_errors", "rustc_lexer", "rustc_target", @@ -3718,6 +3730,7 @@ dependencies = [ "log", "rustc", "rustc_data_structures", + "rustc_error_codes", "rustc_errors", "rustc_index", "rustc_parse", @@ -3738,6 +3751,7 @@ name = "rustc_plugin_impl" version = "0.0.0" dependencies = [ "rustc", + "rustc_error_codes", "rustc_metadata", "syntax", "syntax_expand", @@ -3751,6 +3765,7 @@ dependencies = [ "log", "rustc", "rustc_data_structures", + "rustc_error_codes", "rustc_typeck", "syntax", "syntax_pos", @@ -3765,6 +3780,7 @@ dependencies = [ "log", "rustc", "rustc_data_structures", + "rustc_error_codes", "rustc_errors", "rustc_metadata", "smallvec 1.0.0", @@ -3844,6 +3860,7 @@ dependencies = [ "log", "rustc", "rustc_data_structures", + "rustc_error_codes", "rustc_errors", "rustc_index", "rustc_target", @@ -4380,6 +4397,7 @@ dependencies = [ "lazy_static 1.3.0", "log", "rustc_data_structures", + "rustc_error_codes", "rustc_errors", "rustc_index", "rustc_lexer", @@ -4411,6 +4429,7 @@ dependencies = [ "fmt_macros", "log", "rustc_data_structures", + "rustc_error_codes", "rustc_errors", "rustc_parse", "rustc_target", diff --git a/src/librustc/Cargo.toml b/src/librustc/Cargo.toml index bcbe765b850..adf58d6471b 100644 --- a/src/librustc/Cargo.toml +++ b/src/librustc/Cargo.toml @@ -40,3 +40,5 @@ byteorder = { version = "1.3" } chalk-engine = { version = "0.9.0", default-features=false } rustc_fs_util = { path = "../librustc_fs_util" } smallvec = { version = "1.0", features = ["union", "may_dangle"] } +measureme = "0.4" +rustc_error_codes = { path = "../librustc_error_codes" } diff --git a/src/librustc/error_codes.rs b/src/librustc/error_codes.rs deleted file mode 100644 index d5c2db5fb97..00000000000 --- a/src/librustc/error_codes.rs +++ /dev/null @@ -1,2394 +0,0 @@ -// Error messages for EXXXX errors. -// Each message should start and end with a new line, and be wrapped to 80 -// characters. In vim you can `:set tw=80` and use `gq` to wrap paragraphs. Use -// `:set tw=0` to disable. -syntax::register_diagnostics! { -E0038: r##" -Trait objects like `Box<Trait>` can only be constructed when certain -requirements are satisfied by the trait in question. - -Trait objects are a form of dynamic dispatch and use a dynamically sized type -for the inner type. So, for a given trait `Trait`, when `Trait` is treated as a -type, as in `Box<Trait>`, the inner type is 'unsized'. In such cases the boxed -pointer is a 'fat pointer' that contains an extra pointer to a table of methods -(among other things) for dynamic dispatch. This design mandates some -restrictions on the types of traits that are allowed to be used in trait -objects, which are collectively termed as 'object safety' rules. - -Attempting to create a trait object for a non object-safe trait will trigger -this error. - -There are various rules: - -### The trait cannot require `Self: Sized` - -When `Trait` is treated as a type, the type does not implement the special -`Sized` trait, because the type does not have a known size at compile time and -can only be accessed behind a pointer. Thus, if we have a trait like the -following: - -``` -trait Foo where Self: Sized { - -} -``` - -We cannot create an object of type `Box<Foo>` or `&Foo` since in this case -`Self` would not be `Sized`. - -Generally, `Self: Sized` is used to indicate that the trait should not be used -as a trait object. If the trait comes from your own crate, consider removing -this restriction. - -### Method references the `Self` type in its parameters or return type - -This happens when a trait has a method like the following: - -``` -trait Trait { - fn foo(&self) -> Self; -} - -impl Trait for String { - fn foo(&self) -> Self { - "hi".to_owned() - } -} - -impl Trait for u8 { - fn foo(&self) -> Self { - 1 - } -} -``` - -(Note that `&self` and `&mut self` are okay, it's additional `Self` types which -cause this problem.) - -In such a case, the compiler cannot predict the return type of `foo()` in a -situation like the following: - -```compile_fail -trait Trait { - fn foo(&self) -> Self; -} - -fn call_foo(x: Box<Trait>) { - let y = x.foo(); // What type is y? - // ... -} -``` - -If only some methods aren't object-safe, you can add a `where Self: Sized` bound -on them to mark them as explicitly unavailable to trait objects. The -functionality will still be available to all other implementers, including -`Box<Trait>` which is itself sized (assuming you `impl Trait for Box<Trait>`). - -``` -trait Trait { - fn foo(&self) -> Self where Self: Sized; - // more functions -} -``` - -Now, `foo()` can no longer be called on a trait object, but you will now be -allowed to make a trait object, and that will be able to call any object-safe -methods. With such a bound, one can still call `foo()` on types implementing -that trait that aren't behind trait objects. - -### Method has generic type parameters - -As mentioned before, trait objects contain pointers to method tables. So, if we -have: - -``` -trait Trait { - fn foo(&self); -} - -impl Trait for String { - fn foo(&self) { - // implementation 1 - } -} - -impl Trait for u8 { - fn foo(&self) { - // implementation 2 - } -} -// ... -``` - -At compile time each implementation of `Trait` will produce a table containing -the various methods (and other items) related to the implementation. - -This works fine, but when the method gains generic parameters, we can have a -problem. - -Usually, generic parameters get _monomorphized_. For example, if I have - -``` -fn foo<T>(x: T) { - // ... -} -``` - -The machine code for `foo::<u8>()`, `foo::<bool>()`, `foo::<String>()`, or any -other type substitution is different. Hence the compiler generates the -implementation on-demand. If you call `foo()` with a `bool` parameter, the -compiler will only generate code for `foo::<bool>()`. When we have additional -type parameters, the number of monomorphized implementations the compiler -generates does not grow drastically, since the compiler will only generate an -implementation if the function is called with unparametrized substitutions -(i.e., substitutions where none of the substituted types are themselves -parametrized). - -However, with trait objects we have to make a table containing _every_ object -that implements the trait. Now, if it has type parameters, we need to add -implementations for every type that implements the trait, and there could -theoretically be an infinite number of types. - -For example, with: - -``` -trait Trait { - fn foo<T>(&self, on: T); - // more methods -} - -impl Trait for String { - fn foo<T>(&self, on: T) { - // implementation 1 - } -} - -impl Trait for u8 { - fn foo<T>(&self, on: T) { - // implementation 2 - } -} - -// 8 more implementations -``` - -Now, if we have the following code: - -```compile_fail,E0038 -# trait Trait { fn foo<T>(&self, on: T); } -# impl Trait for String { fn foo<T>(&self, on: T) {} } -# impl Trait for u8 { fn foo<T>(&self, on: T) {} } -# impl Trait for bool { fn foo<T>(&self, on: T) {} } -# // etc. -fn call_foo(thing: Box<Trait>) { - thing.foo(true); // this could be any one of the 8 types above - thing.foo(1); - thing.foo("hello"); -} -``` - -We don't just need to create a table of all implementations of all methods of -`Trait`, we need to create such a table, for each different type fed to -`foo()`. In this case this turns out to be (10 types implementing `Trait`)*(3 -types being fed to `foo()`) = 30 implementations! - -With real world traits these numbers can grow drastically. - -To fix this, it is suggested to use a `where Self: Sized` bound similar to the -fix for the sub-error above if you do not intend to call the method with type -parameters: - -``` -trait Trait { - fn foo<T>(&self, on: T) where Self: Sized; - // more methods -} -``` - -If this is not an option, consider replacing the type parameter with another -trait object (e.g., if `T: OtherTrait`, use `on: Box<OtherTrait>`). If the -number of types you intend to feed to this method is limited, consider manually -listing out the methods of different types. - -### Method has no receiver - -Methods that do not take a `self` parameter can't be called since there won't be -a way to get a pointer to the method table for them. - -``` -trait Foo { - fn foo() -> u8; -} -``` - -This could be called as `<Foo as Foo>::foo()`, which would not be able to pick -an implementation. - -Adding a `Self: Sized` bound to these methods will generally make this compile. - -``` -trait Foo { - fn foo() -> u8 where Self: Sized; -} -``` - -### The trait cannot contain associated constants - -Just like static functions, associated constants aren't stored on the method -table. If the trait or any subtrait contain an associated constant, they cannot -be made into an object. - -```compile_fail,E0038 -trait Foo { - const X: i32; -} - -impl Foo {} -``` - -A simple workaround is to use a helper method instead: - -``` -trait Foo { - fn x(&self) -> i32; -} -``` - -### The trait cannot use `Self` as a type parameter in the supertrait listing - -This is similar to the second sub-error, but subtler. It happens in situations -like the following: - -```compile_fail,E0038 -trait Super<A: ?Sized> {} - -trait Trait: Super<Self> { -} - -struct Foo; - -impl Super<Foo> for Foo{} - -impl Trait for Foo {} - -fn main() { - let x: Box<dyn Trait>; -} -``` - -Here, the supertrait might have methods as follows: - -``` -trait Super<A: ?Sized> { - fn get_a(&self) -> &A; // note that this is object safe! -} -``` - -If the trait `Trait` was deriving from something like `Super<String>` or -`Super<T>` (where `Foo` itself is `Foo<T>`), this is okay, because given a type -`get_a()` will definitely return an object of that type. - -However, if it derives from `Super<Self>`, even though `Super` is object safe, -the method `get_a()` would return an object of unknown type when called on the -function. `Self` type parameters let us make object safe traits no longer safe, -so they are forbidden when specifying supertraits. - -There's no easy fix for this, generally code will need to be refactored so that -you no longer need to derive from `Super<Self>`. -"##, - -E0072: r##" -When defining a recursive struct or enum, any use of the type being defined -from inside the definition must occur behind a pointer (like `Box` or `&`). -This is because structs and enums must have a well-defined size, and without -the pointer, the size of the type would need to be unbounded. - -Consider the following erroneous definition of a type for a list of bytes: - -```compile_fail,E0072 -// error, invalid recursive struct type -struct ListNode { - head: u8, - tail: Option<ListNode>, -} -``` - -This type cannot have a well-defined size, because it needs to be arbitrarily -large (since we would be able to nest `ListNode`s to any depth). Specifically, - -```plain -size of `ListNode` = 1 byte for `head` - + 1 byte for the discriminant of the `Option` - + size of `ListNode` -``` - -One way to fix this is by wrapping `ListNode` in a `Box`, like so: - -``` -struct ListNode { - head: u8, - tail: Option<Box<ListNode>>, -} -``` - -This works because `Box` is a pointer, so its size is well-known. -"##, - -E0080: r##" -This error indicates that the compiler was unable to sensibly evaluate a -constant expression that had to be evaluated. Attempting to divide by 0 -or causing integer overflow are two ways to induce this error. For example: - -```compile_fail,E0080 -enum Enum { - X = (1 << 500), - Y = (1 / 0) -} -``` - -Ensure that the expressions given can be evaluated as the desired integer type. -See the FFI section of the Reference for more information about using a custom -integer type: - -https://doc.rust-lang.org/reference.html#ffi-attributes -"##, - -E0106: r##" -This error indicates that a lifetime is missing from a type. If it is an error -inside a function signature, the problem may be with failing to adhere to the -lifetime elision rules (see below). - -Here are some simple examples of where you'll run into this error: - -```compile_fail,E0106 -struct Foo1 { x: &bool } - // ^ expected lifetime parameter -struct Foo2<'a> { x: &'a bool } // correct - -struct Bar1 { x: Foo2 } - // ^^^^ expected lifetime parameter -struct Bar2<'a> { x: Foo2<'a> } // correct - -enum Baz1 { A(u8), B(&bool), } - // ^ expected lifetime parameter -enum Baz2<'a> { A(u8), B(&'a bool), } // correct - -type MyStr1 = &str; - // ^ expected lifetime parameter -type MyStr2<'a> = &'a str; // correct -``` - -Lifetime elision is a special, limited kind of inference for lifetimes in -function signatures which allows you to leave out lifetimes in certain cases. -For more background on lifetime elision see [the book][book-le]. - -The lifetime elision rules require that any function signature with an elided -output lifetime must either have - - - exactly one input lifetime - - or, multiple input lifetimes, but the function must also be a method with a - `&self` or `&mut self` receiver - -In the first case, the output lifetime is inferred to be the same as the unique -input lifetime. In the second case, the lifetime is instead inferred to be the -same as the lifetime on `&self` or `&mut self`. - -Here are some examples of elision errors: - -```compile_fail,E0106 -// error, no input lifetimes -fn foo() -> &str { } - -// error, `x` and `y` have distinct lifetimes inferred -fn bar(x: &str, y: &str) -> &str { } - -// error, `y`'s lifetime is inferred to be distinct from `x`'s -fn baz<'a>(x: &'a str, y: &str) -> &str { } -``` - -[book-le]: https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html#lifetime-elision -"##, - -E0119: r##" -There are conflicting trait implementations for the same type. -Example of erroneous code: - -```compile_fail,E0119 -trait MyTrait { - fn get(&self) -> usize; -} - -impl<T> MyTrait for T { - fn get(&self) -> usize { 0 } -} - -struct Foo { - value: usize -} - -impl MyTrait for Foo { // error: conflicting implementations of trait - // `MyTrait` for type `Foo` - fn get(&self) -> usize { self.value } -} -``` - -When looking for the implementation for the trait, the compiler finds -both the `impl<T> MyTrait for T` where T is all types and the `impl -MyTrait for Foo`. Since a trait cannot be implemented multiple times, -this is an error. So, when you write: - -``` -trait MyTrait { - fn get(&self) -> usize; -} - -impl<T> MyTrait for T { - fn get(&self) -> usize { 0 } -} -``` - -This makes the trait implemented on all types in the scope. So if you -try to implement it on another one after that, the implementations will -conflict. Example: - -``` -trait MyTrait { - fn get(&self) -> usize; -} - -impl<T> MyTrait for T { - fn get(&self) -> usize { 0 } -} - -struct Foo; - -fn main() { - let f = Foo; - - f.get(); // the trait is implemented so we can use it -} -``` -"##, - -E0139: r##" -#### Note: this error code is no longer emitted by the compiler. - -There are various restrictions on transmuting between types in Rust; for example -types being transmuted must have the same size. To apply all these restrictions, -the compiler must know the exact types that may be transmuted. When type -parameters are involved, this cannot always be done. - -So, for example, the following is not allowed: - -``` -use std::mem::transmute; - -struct Foo<T>(Vec<T>); - -fn foo<T>(x: Vec<T>) { - // we are transmuting between Vec<T> and Foo<F> here - let y: Foo<T> = unsafe { transmute(x) }; - // do something with y -} -``` - -In this specific case there's a good chance that the transmute is harmless (but -this is not guaranteed by Rust). However, when alignment and enum optimizations -come into the picture, it's quite likely that the sizes may or may not match -with different type parameter substitutions. It's not possible to check this for -_all_ possible types, so `transmute()` simply only accepts types without any -unsubstituted type parameters. - -If you need this, there's a good chance you're doing something wrong. Keep in -mind that Rust doesn't guarantee much about the layout of different structs -(even two structs with identical declarations may have different layouts). If -there is a solution that avoids the transmute entirely, try it instead. - -If it's possible, hand-monomorphize the code by writing the function for each -possible type substitution. It's possible to use traits to do this cleanly, -for example: - -``` -use std::mem::transmute; - -struct Foo<T>(Vec<T>); - -trait MyTransmutableType: Sized { - fn transmute(_: Vec<Self>) -> Foo<Self>; -} - -impl MyTransmutableType for u8 { - fn transmute(x: Vec<u8>) -> Foo<u8> { - unsafe { transmute(x) } - } -} - -impl MyTransmutableType for String { - fn transmute(x: Vec<String>) -> Foo<String> { - unsafe { transmute(x) } - } -} - -// ... more impls for the types you intend to transmute - -fn foo<T: MyTransmutableType>(x: Vec<T>) { - let y: Foo<T> = <T as MyTransmutableType>::transmute(x); - // do something with y -} -``` - -Each impl will be checked for a size match in the transmute as usual, and since -there are no unbound type parameters involved, this should compile unless there -is a size mismatch in one of the impls. - -It is also possible to manually transmute: - -``` -# use std::ptr; -# let v = Some("value"); -# type SomeType = &'static [u8]; -unsafe { - ptr::read(&v as *const _ as *const SomeType) // `v` transmuted to `SomeType` -} -# ; -``` - -Note that this does not move `v` (unlike `transmute`), and may need a -call to `mem::forget(v)` in case you want to avoid destructors being called. -"##, - -E0152: r##" -A lang item was redefined. - -Erroneous code example: - -```compile_fail,E0152 -#![feature(lang_items)] - -#[lang = "arc"] -struct Foo; // error: duplicate lang item found: `arc` -``` - -Lang items are already implemented in the standard library. Unless you are -writing a free-standing application (e.g., a kernel), you do not need to provide -them yourself. - -You can build a free-standing crate by adding `#![no_std]` to the crate -attributes: - -```ignore (only-for-syntax-highlight) -#![no_std] -``` - -See also the [unstable book][1]. - -[1]: https://doc.rust-lang.org/unstable-book/language-features/lang-items.html#writing-an-executable-without-stdlib -"##, - -E0214: r##" -A generic type was described using parentheses rather than angle brackets. -For example: - -```compile_fail,E0214 -fn main() { - let v: Vec(&str) = vec!["foo"]; -} -``` - -This is not currently supported: `v` should be defined as `Vec<&str>`. -Parentheses are currently only used with generic types when defining parameters -for `Fn`-family traits. -"##, - -E0230: r##" -The `#[rustc_on_unimplemented]` attribute lets you specify a custom error -message for when a particular trait isn't implemented on a type placed in a -position that needs that trait. For example, when the following code is -compiled: - -```compile_fail -#![feature(rustc_attrs)] - -fn foo<T: Index<u8>>(x: T){} - -#[rustc_on_unimplemented = "the type `{Self}` cannot be indexed by `{Idx}`"] -trait Index<Idx> { /* ... */ } - -foo(true); // `bool` does not implement `Index<u8>` -``` - -There will be an error about `bool` not implementing `Index<u8>`, followed by a -note saying "the type `bool` cannot be indexed by `u8`". - -As you can see, you can specify type parameters in curly braces for -substitution with the actual types (using the regular format string syntax) in -a given situation. Furthermore, `{Self}` will substitute to the type (in this -case, `bool`) that we tried to use. - -This error appears when the curly braces contain an identifier which doesn't -match with any of the type parameters or the string `Self`. This might happen -if you misspelled a type parameter, or if you intended to use literal curly -braces. If it is the latter, escape the curly braces with a second curly brace -of the same type; e.g., a literal `{` is `{{`. -"##, - -E0231: r##" -The `#[rustc_on_unimplemented]` attribute lets you specify a custom error -message for when a particular trait isn't implemented on a type placed in a -position that needs that trait. For example, when the following code is -compiled: - -```compile_fail -#![feature(rustc_attrs)] - -fn foo<T: Index<u8>>(x: T){} - -#[rustc_on_unimplemented = "the type `{Self}` cannot be indexed by `{Idx}`"] -trait Index<Idx> { /* ... */ } - -foo(true); // `bool` does not implement `Index<u8>` -``` - -there will be an error about `bool` not implementing `Index<u8>`, followed by a -note saying "the type `bool` cannot be indexed by `u8`". - -As you can see, you can specify type parameters in curly braces for -substitution with the actual types (using the regular format string syntax) in -a given situation. Furthermore, `{Self}` will substitute to the type (in this -case, `bool`) that we tried to use. - -This error appears when the curly braces do not contain an identifier. Please -add one of the same name as a type parameter. If you intended to use literal -braces, use `{{` and `}}` to escape them. -"##, - -E0232: r##" -The `#[rustc_on_unimplemented]` attribute lets you specify a custom error -message for when a particular trait isn't implemented on a type placed in a -position that needs that trait. For example, when the following code is -compiled: - -```compile_fail -#![feature(rustc_attrs)] - -fn foo<T: Index<u8>>(x: T){} - -#[rustc_on_unimplemented = "the type `{Self}` cannot be indexed by `{Idx}`"] -trait Index<Idx> { /* ... */ } - -foo(true); // `bool` does not implement `Index<u8>` -``` - -there will be an error about `bool` not implementing `Index<u8>`, followed by a -note saying "the type `bool` cannot be indexed by `u8`". - -For this to work, some note must be specified. An empty attribute will not do -anything, please remove the attribute or add some helpful note for users of the -trait. -"##, - -E0261: r##" -When using a lifetime like `'a` in a type, it must be declared before being -used. - -These two examples illustrate the problem: - -```compile_fail,E0261 -// error, use of undeclared lifetime name `'a` -fn foo(x: &'a str) { } - -struct Foo { - // error, use of undeclared lifetime name `'a` - x: &'a str, -} -``` - -These can be fixed by declaring lifetime parameters: - -``` -struct Foo<'a> { - x: &'a str, -} - -fn foo<'a>(x: &'a str) {} -``` - -Impl blocks declare lifetime parameters separately. You need to add lifetime -parameters to an impl block if you're implementing a type that has a lifetime -parameter of its own. -For example: - -```compile_fail,E0261 -struct Foo<'a> { - x: &'a str, -} - -// error, use of undeclared lifetime name `'a` -impl Foo<'a> { - fn foo<'a>(x: &'a str) {} -} -``` - -This is fixed by declaring the impl block like this: - -``` -struct Foo<'a> { - x: &'a str, -} - -// correct -impl<'a> Foo<'a> { - fn foo(x: &'a str) {} -} -``` -"##, - -E0262: r##" -Declaring certain lifetime names in parameters is disallowed. For example, -because the `'static` lifetime is a special built-in lifetime name denoting -the lifetime of the entire program, this is an error: - -```compile_fail,E0262 -// error, invalid lifetime parameter name `'static` -fn foo<'static>(x: &'static str) { } -``` -"##, - -E0263: r##" -A lifetime name cannot be declared more than once in the same scope. For -example: - -```compile_fail,E0263 -// error, lifetime name `'a` declared twice in the same scope -fn foo<'a, 'b, 'a>(x: &'a str, y: &'b str) { } -``` -"##, - -E0264: r##" -An unknown external lang item was used. Erroneous code example: - -```compile_fail,E0264 -#![feature(lang_items)] - -extern "C" { - #[lang = "cake"] // error: unknown external lang item: `cake` - fn cake(); -} -``` - -A list of available external lang items is available in -`src/librustc/middle/weak_lang_items.rs`. Example: - -``` -#![feature(lang_items)] - -extern "C" { - #[lang = "panic_impl"] // ok! - fn cake(); -} -``` -"##, - -E0271: r##" -This is because of a type mismatch between the associated type of some -trait (e.g., `T::Bar`, where `T` implements `trait Quux { type Bar; }`) -and another type `U` that is required to be equal to `T::Bar`, but is not. -Examples follow. - -Here is a basic example: - -```compile_fail,E0271 -trait Trait { type AssociatedType; } - -fn foo<T>(t: T) where T: Trait<AssociatedType=u32> { - println!("in foo"); -} - -impl Trait for i8 { type AssociatedType = &'static str; } - -foo(3_i8); -``` - -Here is that same example again, with some explanatory comments: - -```compile_fail,E0271 -trait Trait { type AssociatedType; } - -fn foo<T>(t: T) where T: Trait<AssociatedType=u32> { -// ~~~~~~~~ ~~~~~~~~~~~~~~~~~~ -// | | -// This says `foo` can | -// only be used with | -// some type that | -// implements `Trait`. | -// | -// This says not only must -// `T` be an impl of `Trait` -// but also that the impl -// must assign the type `u32` -// to the associated type. - println!("in foo"); -} - -impl Trait for i8 { type AssociatedType = &'static str; } -//~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -// | | -// `i8` does have | -// implementation | -// of `Trait`... | -// ... but it is an implementation -// that assigns `&'static str` to -// the associated type. - -foo(3_i8); -// Here, we invoke `foo` with an `i8`, which does not satisfy -// the constraint `<i8 as Trait>::AssociatedType=u32`, and -// therefore the type-checker complains with this error code. -``` - -To avoid those issues, you have to make the types match correctly. -So we can fix the previous examples like this: - -``` -// Basic Example: -trait Trait { type AssociatedType; } - -fn foo<T>(t: T) where T: Trait<AssociatedType = &'static str> { - println!("in foo"); -} - -impl Trait for i8 { type AssociatedType = &'static str; } - -foo(3_i8); - -// For-Loop Example: -let vs = vec![1, 2, 3, 4]; -for v in &vs { - match v { - &1 => {} - _ => {} - } -} -``` -"##, - - -E0275: r##" -This error occurs when there was a recursive trait requirement that overflowed -before it could be evaluated. Often this means that there is unbounded -recursion in resolving some type bounds. - -For example, in the following code: - -```compile_fail,E0275 -trait Foo {} - -struct Bar<T>(T); - -impl<T> Foo for T where Bar<T>: Foo {} -``` - -To determine if a `T` is `Foo`, we need to check if `Bar<T>` is `Foo`. However, -to do this check, we need to determine that `Bar<Bar<T>>` is `Foo`. To -determine this, we check if `Bar<Bar<Bar<T>>>` is `Foo`, and so on. This is -clearly a recursive requirement that can't be resolved directly. - -Consider changing your trait bounds so that they're less self-referential. -"##, - -E0276: r##" -This error occurs when a bound in an implementation of a trait does not match -the bounds specified in the original trait. For example: - -```compile_fail,E0276 -trait Foo { - fn foo<T>(x: T); -} - -impl Foo for bool { - fn foo<T>(x: T) where T: Copy {} -} -``` - -Here, all types implementing `Foo` must have a method `foo<T>(x: T)` which can -take any type `T`. However, in the `impl` for `bool`, we have added an extra -bound that `T` is `Copy`, which isn't compatible with the original trait. - -Consider removing the bound from the method or adding the bound to the original -method definition in the trait. -"##, - -E0277: r##" -You tried to use a type which doesn't implement some trait in a place which -expected that trait. Erroneous code example: - -```compile_fail,E0277 -// here we declare the Foo trait with a bar method -trait Foo { - fn bar(&self); -} - -// we now declare a function which takes an object implementing the Foo trait -fn some_func<T: Foo>(foo: T) { - foo.bar(); -} - -fn main() { - // we now call the method with the i32 type, which doesn't implement - // the Foo trait - some_func(5i32); // error: the trait bound `i32 : Foo` is not satisfied -} -``` - -In order to fix this error, verify that the type you're using does implement -the trait. Example: - -``` -trait Foo { - fn bar(&self); -} - -fn some_func<T: Foo>(foo: T) { - foo.bar(); // we can now use this method since i32 implements the - // Foo trait -} - -// we implement the trait on the i32 type -impl Foo for i32 { - fn bar(&self) {} -} - -fn main() { - some_func(5i32); // ok! -} -``` - -Or in a generic context, an erroneous code example would look like: - -```compile_fail,E0277 -fn some_func<T>(foo: T) { - println!("{:?}", foo); // error: the trait `core::fmt::Debug` is not - // implemented for the type `T` -} - -fn main() { - // We now call the method with the i32 type, - // which *does* implement the Debug trait. - some_func(5i32); -} -``` - -Note that the error here is in the definition of the generic function: Although -we only call it with a parameter that does implement `Debug`, the compiler -still rejects the function: It must work with all possible input types. In -order to make this example compile, we need to restrict the generic type we're -accepting: - -``` -use std::fmt; - -// Restrict the input type to types that implement Debug. -fn some_func<T: fmt::Debug>(foo: T) { - println!("{:?}", foo); -} - -fn main() { - // Calling the method is still fine, as i32 implements Debug. - some_func(5i32); - - // This would fail to compile now: - // struct WithoutDebug; - // some_func(WithoutDebug); -} -``` - -Rust only looks at the signature of the called function, as such it must -already specify all requirements that will be used for every type parameter. -"##, - -E0281: r##" -#### Note: this error code is no longer emitted by the compiler. - -You tried to supply a type which doesn't implement some trait in a location -which expected that trait. This error typically occurs when working with -`Fn`-based types. Erroneous code example: - -```compile-fail -fn foo<F: Fn(usize)>(x: F) { } - -fn main() { - // type mismatch: ... implements the trait `core::ops::Fn<(String,)>`, - // but the trait `core::ops::Fn<(usize,)>` is required - // [E0281] - foo(|y: String| { }); -} -``` - -The issue in this case is that `foo` is defined as accepting a `Fn` with one -argument of type `String`, but the closure we attempted to pass to it requires -one arguments of type `usize`. -"##, - -E0282: r##" -This error indicates that type inference did not result in one unique possible -type, and extra information is required. In most cases this can be provided -by adding a type annotation. Sometimes you need to specify a generic type -parameter manually. - -A common example is the `collect` method on `Iterator`. It has a generic type -parameter with a `FromIterator` bound, which for a `char` iterator is -implemented by `Vec` and `String` among others. Consider the following snippet -that reverses the characters of a string: - -```compile_fail,E0282 -let x = "hello".chars().rev().collect(); -``` - -In this case, the compiler cannot infer what the type of `x` should be: -`Vec<char>` and `String` are both suitable candidates. To specify which type to -use, you can use a type annotation on `x`: - -``` -let x: Vec<char> = "hello".chars().rev().collect(); -``` - -It is not necessary to annotate the full type. Once the ambiguity is resolved, -the compiler can infer the rest: - -``` -let x: Vec<_> = "hello".chars().rev().collect(); -``` - -Another way to provide the compiler with enough information, is to specify the -generic type parameter: - -``` -let x = "hello".chars().rev().collect::<Vec<char>>(); -``` - -Again, you need not specify the full type if the compiler can infer it: - -``` -let x = "hello".chars().rev().collect::<Vec<_>>(); -``` - -Apart from a method or function with a generic type parameter, this error can -occur when a type parameter of a struct or trait cannot be inferred. In that -case it is not always possible to use a type annotation, because all candidates -have the same return type. For instance: - -```compile_fail,E0282 -struct Foo<T> { - num: T, -} - -impl<T> Foo<T> { - fn bar() -> i32 { - 0 - } - - fn baz() { - let number = Foo::bar(); - } -} -``` - -This will fail because the compiler does not know which instance of `Foo` to -call `bar` on. Change `Foo::bar()` to `Foo::<T>::bar()` to resolve the error. -"##, - -E0283: r##" -This error occurs when the compiler doesn't have enough information -to unambiguously choose an implementation. - -For example: - -```compile_fail,E0283 -trait Generator { - fn create() -> u32; -} - -struct Impl; - -impl Generator for Impl { - fn create() -> u32 { 1 } -} - -struct AnotherImpl; - -impl Generator for AnotherImpl { - fn create() -> u32 { 2 } -} - -fn main() { - let cont: u32 = Generator::create(); - // error, impossible to choose one of Generator trait implementation - // Should it be Impl or AnotherImpl, maybe something else? -} -``` - -To resolve this error use the concrete type: - -``` -trait Generator { - fn create() -> u32; -} - -struct AnotherImpl; - -impl Generator for AnotherImpl { - fn create() -> u32 { 2 } -} - -fn main() { - let gen1 = AnotherImpl::create(); - - // if there are multiple methods with same name (different traits) - let gen2 = <AnotherImpl as Generator>::create(); -} -``` -"##, - -E0284: r##" -This error occurs when the compiler is unable to unambiguously infer the -return type of a function or method which is generic on return type, such -as the `collect` method for `Iterator`s. - -For example: - -```compile_fail,E0284 -fn foo() -> Result<bool, ()> { - let results = [Ok(true), Ok(false), Err(())].iter().cloned(); - let v: Vec<bool> = results.collect()?; - // Do things with v... - Ok(true) -} -``` - -Here we have an iterator `results` over `Result<bool, ()>`. -Hence, `results.collect()` can return any type implementing -`FromIterator<Result<bool, ()>>`. On the other hand, the -`?` operator can accept any type implementing `Try`. - -The author of this code probably wants `collect()` to return a -`Result<Vec<bool>, ()>`, but the compiler can't be sure -that there isn't another type `T` implementing both `Try` and -`FromIterator<Result<bool, ()>>` in scope such that -`T::Ok == Vec<bool>`. Hence, this code is ambiguous and an error -is returned. - -To resolve this error, use a concrete type for the intermediate expression: - -``` -fn foo() -> Result<bool, ()> { - let results = [Ok(true), Ok(false), Err(())].iter().cloned(); - let v = { - let temp: Result<Vec<bool>, ()> = results.collect(); - temp? - }; - // Do things with v... - Ok(true) -} -``` - -Note that the type of `v` can now be inferred from the type of `temp`. -"##, - -E0308: r##" -This error occurs when the compiler was unable to infer the concrete type of a -variable. It can occur for several cases, the most common of which is a -mismatch in the expected type that the compiler inferred for a variable's -initializing expression, and the actual type explicitly assigned to the -variable. - -For example: - -```compile_fail,E0308 -let x: i32 = "I am not a number!"; -// ~~~ ~~~~~~~~~~~~~~~~~~~~ -// | | -// | initializing expression; -// | compiler infers type `&str` -// | -// type `i32` assigned to variable `x` -``` -"##, - -E0309: r##" -The type definition contains some field whose type -requires an outlives annotation. Outlives annotations -(e.g., `T: 'a`) are used to guarantee that all the data in T is valid -for at least the lifetime `'a`. This scenario most commonly -arises when the type contains an associated type reference -like `<T as SomeTrait<'a>>::Output`, as shown in this example: - -```compile_fail,E0309 -// This won't compile because the applicable impl of -// `SomeTrait` (below) requires that `T: 'a`, but the struct does -// not have a matching where-clause. -struct Foo<'a, T> { - foo: <T as SomeTrait<'a>>::Output, -} - -trait SomeTrait<'a> { - type Output; -} - -impl<'a, T> SomeTrait<'a> for T -where - T: 'a, -{ - type Output = u32; -} -``` - -Here, the where clause `T: 'a` that appears on the impl is not known to be -satisfied on the struct. To make this example compile, you have to add -a where-clause like `T: 'a` to the struct definition: - -``` -struct Foo<'a, T> -where - T: 'a, -{ - foo: <T as SomeTrait<'a>>::Output -} - -trait SomeTrait<'a> { - type Output; -} - -impl<'a, T> SomeTrait<'a> for T -where - T: 'a, -{ - type Output = u32; -} -``` -"##, - -E0310: r##" -Types in type definitions have lifetimes associated with them that represent -how long the data stored within them is guaranteed to be live. This lifetime -must be as long as the data needs to be alive, and missing the constraint that -denotes this will cause this error. - -```compile_fail,E0310 -// This won't compile because T is not constrained to the static lifetime -// the reference needs -struct Foo<T> { - foo: &'static T -} -``` - -This will compile, because it has the constraint on the type parameter: - -``` -struct Foo<T: 'static> { - foo: &'static T -} -``` -"##, - -E0312: r##" -Reference's lifetime of borrowed content doesn't match the expected lifetime. - -Erroneous code example: - -```compile_fail,E0312 -pub fn opt_str<'a>(maybestr: &'a Option<String>) -> &'static str { - if maybestr.is_none() { - "(none)" - } else { - let s: &'a str = maybestr.as_ref().unwrap(); - s // Invalid lifetime! - } -} -``` - -To fix this error, either lessen the expected lifetime or find a way to not have -to use this reference outside of its current scope (by running the code directly -in the same block for example?): - -``` -// In this case, we can fix the issue by switching from "static" lifetime to 'a -pub fn opt_str<'a>(maybestr: &'a Option<String>) -> &'a str { - if maybestr.is_none() { - "(none)" - } else { - let s: &'a str = maybestr.as_ref().unwrap(); - s // Ok! - } -} -``` -"##, - -E0317: r##" -This error occurs when an `if` expression without an `else` block is used in a -context where a type other than `()` is expected, for example a `let` -expression: - -```compile_fail,E0317 -fn main() { - let x = 5; - let a = if x == 5 { 1 }; -} -``` - -An `if` expression without an `else` block has the type `()`, so this is a type -error. To resolve it, add an `else` block having the same type as the `if` -block. -"##, - -E0391: r##" -This error indicates that some types or traits depend on each other -and therefore cannot be constructed. - -The following example contains a circular dependency between two traits: - -```compile_fail,E0391 -trait FirstTrait : SecondTrait { - -} - -trait SecondTrait : FirstTrait { - -} -``` -"##, - -E0398: r##" -#### Note: this error code is no longer emitted by the compiler. - -In Rust 1.3, the default object lifetime bounds are expected to change, as -described in [RFC 1156]. You are getting a warning because the compiler -thinks it is possible that this change will cause a compilation error in your -code. It is possible, though unlikely, that this is a false alarm. - -The heart of the change is that where `&'a Box<SomeTrait>` used to default to -`&'a Box<SomeTrait+'a>`, it now defaults to `&'a Box<SomeTrait+'static>` (here, -`SomeTrait` is the name of some trait type). Note that the only types which are -affected are references to boxes, like `&Box<SomeTrait>` or -`&[Box<SomeTrait>]`. More common types like `&SomeTrait` or `Box<SomeTrait>` -are unaffected. - -To silence this warning, edit your code to use an explicit bound. Most of the -time, this means that you will want to change the signature of a function that -you are calling. For example, if the error is reported on a call like `foo(x)`, -and `foo` is defined as follows: - -``` -# trait SomeTrait {} -fn foo(arg: &Box<SomeTrait>) { /* ... */ } -``` - -You might change it to: - -``` -# trait SomeTrait {} -fn foo<'a>(arg: &'a Box<SomeTrait+'a>) { /* ... */ } -``` - -This explicitly states that you expect the trait object `SomeTrait` to contain -references (with a maximum lifetime of `'a`). - -[RFC 1156]: https://github.com/rust-lang/rfcs/blob/master/text/1156-adjust-default-object-bounds.md -"##, - -E0452: r##" -An invalid lint attribute has been given. Erroneous code example: - -```compile_fail,E0452 -#![allow(foo = "")] // error: malformed lint attribute -``` - -Lint attributes only accept a list of identifiers (where each identifier is a -lint name). Ensure the attribute is of this form: - -``` -#![allow(foo)] // ok! -// or: -#![allow(foo, foo2)] // ok! -``` -"##, - -E0453: r##" -A lint check attribute was overruled by a `forbid` directive set as an -attribute on an enclosing scope, or on the command line with the `-F` option. - -Example of erroneous code: - -```compile_fail,E0453 -#![forbid(non_snake_case)] - -#[allow(non_snake_case)] -fn main() { - let MyNumber = 2; // error: allow(non_snake_case) overruled by outer - // forbid(non_snake_case) -} -``` - -The `forbid` lint setting, like `deny`, turns the corresponding compiler -warning into a hard error. Unlike `deny`, `forbid` prevents itself from being -overridden by inner attributes. - -If you're sure you want to override the lint check, you can change `forbid` to -`deny` (or use `-D` instead of `-F` if the `forbid` setting was given as a -command-line option) to allow the inner lint check attribute: - -``` -#![deny(non_snake_case)] - -#[allow(non_snake_case)] -fn main() { - let MyNumber = 2; // ok! -} -``` - -Otherwise, edit the code to pass the lint check, and remove the overruled -attribute: - -``` -#![forbid(non_snake_case)] - -fn main() { - let my_number = 2; -} -``` -"##, - -E0478: r##" -A lifetime bound was not satisfied. - -Erroneous code example: - -```compile_fail,E0478 -// Check that the explicit lifetime bound (`'SnowWhite`, in this example) must -// outlive all the superbounds from the trait (`'kiss`, in this example). - -trait Wedding<'t>: 't { } - -struct Prince<'kiss, 'SnowWhite> { - child: Box<Wedding<'kiss> + 'SnowWhite>, - // error: lifetime bound not satisfied -} -``` - -In this example, the `'SnowWhite` lifetime is supposed to outlive the `'kiss` -lifetime but the declaration of the `Prince` struct doesn't enforce it. To fix -this issue, you need to specify it: - -``` -trait Wedding<'t>: 't { } - -struct Prince<'kiss, 'SnowWhite: 'kiss> { // You say here that 'kiss must live - // longer than 'SnowWhite. - child: Box<Wedding<'kiss> + 'SnowWhite>, // And now it's all good! -} -``` -"##, - -E0491: r##" -A reference has a longer lifetime than the data it references. - -Erroneous code example: - -```compile_fail,E0491 -trait SomeTrait<'a> { - type Output; -} - -impl<'a, T> SomeTrait<'a> for T { - type Output = &'a T; // compile error E0491 -} -``` - -Here, the problem is that a reference type like `&'a T` is only valid -if all the data in T outlives the lifetime `'a`. But this impl as written -is applicable to any lifetime `'a` and any type `T` -- we have no guarantee -that `T` outlives `'a`. To fix this, you can add a where clause like -`where T: 'a`. - -``` -trait SomeTrait<'a> { - type Output; -} - -impl<'a, T> SomeTrait<'a> for T -where - T: 'a, -{ - type Output = &'a T; // compile error E0491 -} -``` -"##, - -E0495: r##" -A lifetime cannot be determined in the given situation. - -Erroneous code example: - -```compile_fail,E0495 -fn transmute_lifetime<'a, 'b, T>(t: &'a (T,)) -> &'b T { - match (&t,) { // error! - ((u,),) => u, - } -} - -let y = Box::new((42,)); -let x = transmute_lifetime(&y); -``` - -In this code, you have two ways to solve this issue: - 1. Enforce that `'a` lives at least as long as `'b`. - 2. Use the same lifetime requirement for both input and output values. - -So for the first solution, you can do it by replacing `'a` with `'a: 'b`: - -``` -fn transmute_lifetime<'a: 'b, 'b, T>(t: &'a (T,)) -> &'b T { - match (&t,) { // ok! - ((u,),) => u, - } -} -``` - -In the second you can do it by simply removing `'b` so they both use `'a`: - -``` -fn transmute_lifetime<'a, T>(t: &'a (T,)) -> &'a T { - match (&t,) { // ok! - ((u,),) => u, - } -} -``` -"##, - -E0496: r##" -A lifetime name is shadowing another lifetime name. - -Erroneous code example: - -```compile_fail,E0496 -struct Foo<'a> { - a: &'a i32, -} - -impl<'a> Foo<'a> { - fn f<'a>(x: &'a i32) { // error: lifetime name `'a` shadows a lifetime - // name that is already in scope - } -} -``` - -Please change the name of one of the lifetimes to remove this error. Example: - -``` -struct Foo<'a> { - a: &'a i32, -} - -impl<'a> Foo<'a> { - fn f<'b>(x: &'b i32) { // ok! - } -} - -fn main() { -} -``` -"##, - -E0497: r##" -#### Note: this error code is no longer emitted by the compiler. - -A stability attribute was used outside of the standard library. - -Erroneous code example: - -```compile_fail -#[stable] // error: stability attributes may not be used outside of the - // standard library -fn foo() {} -``` - -It is not possible to use stability attributes outside of the standard library. -Also, for now, it is not possible to write deprecation messages either. -"##, - -E0517: r##" -This error indicates that a `#[repr(..)]` attribute was placed on an -unsupported item. - -Examples of erroneous code: - -```compile_fail,E0517 -#[repr(C)] -type Foo = u8; - -#[repr(packed)] -enum Foo {Bar, Baz} - -#[repr(u8)] -struct Foo {bar: bool, baz: bool} - -#[repr(C)] -impl Foo { - // ... -} -``` - -* The `#[repr(C)]` attribute can only be placed on structs and enums. -* The `#[repr(packed)]` and `#[repr(simd)]` attributes only work on structs. -* The `#[repr(u8)]`, `#[repr(i16)]`, etc attributes only work on enums. - -These attributes do not work on typedefs, since typedefs are just aliases. - -Representations like `#[repr(u8)]`, `#[repr(i64)]` are for selecting the -discriminant size for enums with no data fields on any of the variants, e.g. -`enum Color {Red, Blue, Green}`, effectively setting the size of the enum to -the size of the provided type. Such an enum can be cast to a value of the same -type as well. In short, `#[repr(u8)]` makes the enum behave like an integer -with a constrained set of allowed values. - -Only field-less enums can be cast to numerical primitives, so this attribute -will not apply to structs. - -`#[repr(packed)]` reduces padding to make the struct size smaller. The -representation of enums isn't strictly defined in Rust, and this attribute -won't work on enums. - -`#[repr(simd)]` will give a struct consisting of a homogeneous series of machine -types (i.e., `u8`, `i32`, etc) a representation that permits vectorization via -SIMD. This doesn't make much sense for enums since they don't consist of a -single list of data. -"##, - -E0518: r##" -This error indicates that an `#[inline(..)]` attribute was incorrectly placed -on something other than a function or method. - -Examples of erroneous code: - -```compile_fail,E0518 -#[inline(always)] -struct Foo; - -#[inline(never)] -impl Foo { - // ... -} -``` - -`#[inline]` hints the compiler whether or not to attempt to inline a method or -function. By default, the compiler does a pretty good job of figuring this out -itself, but if you feel the need for annotations, `#[inline(always)]` and -`#[inline(never)]` can override or force the compiler's decision. - -If you wish to apply this attribute to all methods in an impl, manually annotate -each method; it is not possible to annotate the entire impl with an `#[inline]` -attribute. -"##, - -E0522: r##" -The lang attribute is intended for marking special items that are built-in to -Rust itself. This includes special traits (like `Copy` and `Sized`) that affect -how the compiler behaves, as well as special functions that may be automatically -invoked (such as the handler for out-of-bounds accesses when indexing a slice). -Erroneous code example: - -```compile_fail,E0522 -#![feature(lang_items)] - -#[lang = "cookie"] -fn cookie() -> ! { // error: definition of an unknown language item: `cookie` - loop {} -} -``` -"##, - -E0525: r##" -A closure was used but didn't implement the expected trait. - -Erroneous code example: - -```compile_fail,E0525 -struct X; - -fn foo<T>(_: T) {} -fn bar<T: Fn(u32)>(_: T) {} - -fn main() { - let x = X; - let closure = |_| foo(x); // error: expected a closure that implements - // the `Fn` trait, but this closure only - // implements `FnOnce` - bar(closure); -} -``` - -In the example above, `closure` is an `FnOnce` closure whereas the `bar` -function expected an `Fn` closure. In this case, it's simple to fix the issue, -you just have to implement `Copy` and `Clone` traits on `struct X` and it'll -be ok: - -``` -#[derive(Clone, Copy)] // We implement `Clone` and `Copy` traits. -struct X; - -fn foo<T>(_: T) {} -fn bar<T: Fn(u32)>(_: T) {} - -fn main() { - let x = X; - let closure = |_| foo(x); - bar(closure); // ok! -} -``` - -To understand better how closures work in Rust, read: -https://doc.rust-lang.org/book/ch13-01-closures.html -"##, - -E0566: r##" -Conflicting representation hints have been used on a same item. - -Erroneous code example: - -``` -#[repr(u32, u64)] // warning! -enum Repr { A } -``` - -In most cases (if not all), using just one representation hint is more than -enough. If you want to have a representation hint depending on the current -architecture, use `cfg_attr`. Example: - -``` -#[cfg_attr(linux, repr(u32))] -#[cfg_attr(not(linux), repr(u64))] -enum Repr { A } -``` -"##, - -E0580: r##" -The `main` function was incorrectly declared. - -Erroneous code example: - -```compile_fail,E0580 -fn main(x: i32) { // error: main function has wrong type - println!("{}", x); -} -``` - -The `main` function prototype should never take arguments. -Example: - -``` -fn main() { - // your code -} -``` - -If you want to get command-line arguments, use `std::env::args`. To exit with a -specified exit code, use `std::process::exit`. -"##, - -E0562: r##" -Abstract return types (written `impl Trait` for some trait `Trait`) are only -allowed as function and inherent impl return types. - -Erroneous code example: - -```compile_fail,E0562 -fn main() { - let count_to_ten: impl Iterator<Item=usize> = 0..10; - // error: `impl Trait` not allowed outside of function and inherent method - // return types - for i in count_to_ten { - println!("{}", i); - } -} -``` - -Make sure `impl Trait` only appears in return-type position. - -``` -fn count_to_n(n: usize) -> impl Iterator<Item=usize> { - 0..n -} - -fn main() { - for i in count_to_n(10) { // ok! - println!("{}", i); - } -} -``` - -See [RFC 1522] for more details. - -[RFC 1522]: https://github.com/rust-lang/rfcs/blob/master/text/1522-conservative-impl-trait.md -"##, - -E0593: r##" -You tried to supply an `Fn`-based type with an incorrect number of arguments -than what was expected. - -Erroneous code example: - -```compile_fail,E0593 -fn foo<F: Fn()>(x: F) { } - -fn main() { - // [E0593] closure takes 1 argument but 0 arguments are required - foo(|y| { }); -} -``` -"##, - -E0602: r##" -An unknown lint was used on the command line. - -Erroneous example: - -```sh -rustc -D bogus omse_file.rs -``` - -Maybe you just misspelled the lint name or the lint doesn't exist anymore. -Either way, try to update/remove it in order to fix the error. -"##, - -E0621: r##" -This error code indicates a mismatch between the lifetimes appearing in the -function signature (i.e., the parameter types and the return type) and the -data-flow found in the function body. - -Erroneous code example: - -```compile_fail,E0621 -fn foo<'a>(x: &'a i32, y: &i32) -> &'a i32 { // error: explicit lifetime - // required in the type of - // `y` - if x > y { x } else { y } -} -``` - -In the code above, the function is returning data borrowed from either `x` or -`y`, but the `'a` annotation indicates that it is returning data only from `x`. -To fix the error, the signature and the body must be made to match. Typically, -this is done by updating the function signature. So, in this case, we change -the type of `y` to `&'a i32`, like so: - -``` -fn foo<'a>(x: &'a i32, y: &'a i32) -> &'a i32 { - if x > y { x } else { y } -} -``` - -Now the signature indicates that the function data borrowed from either `x` or -`y`. Alternatively, you could change the body to not return data from `y`: - -``` -fn foo<'a>(x: &'a i32, y: &i32) -> &'a i32 { - x -} -``` -"##, - -E0623: r##" -A lifetime didn't match what was expected. - -Erroneous code example: - -```compile_fail,E0623 -struct Foo<'a> { - x: &'a isize, -} - -fn bar<'short, 'long>(c: Foo<'short>, l: &'long isize) { - let _: Foo<'long> = c; // error! -} -``` - -In this example, we tried to set a value with an incompatible lifetime to -another one (`'long` is unrelated to `'short`). We can solve this issue in -two different ways: - -Either we make `'short` live at least as long as `'long`: - -``` -struct Foo<'a> { - x: &'a isize, -} - -// we set 'short to live at least as long as 'long -fn bar<'short: 'long, 'long>(c: Foo<'short>, l: &'long isize) { - let _: Foo<'long> = c; // ok! -} -``` - -Or we use only one lifetime: - -``` -struct Foo<'a> { - x: &'a isize, -} - -fn bar<'short>(c: Foo<'short>, l: &'short isize) { - let _: Foo<'short> = c; // ok! -} -``` -"##, - -E0635: r##" -The `#![feature]` attribute specified an unknown feature. - -Erroneous code example: - -```compile_fail,E0635 -#![feature(nonexistent_rust_feature)] // error: unknown feature -``` - -"##, - -E0636: r##" -A `#![feature]` attribute was declared multiple times. - -Erroneous code example: - -```compile_fail,E0636 -#![allow(stable_features)] -#![feature(rust1)] -#![feature(rust1)] // error: the feature `rust1` has already been declared -``` - -"##, - -E0644: r##" -A closure or generator was constructed that references its own type. - -Erroneous example: - -```compile-fail,E0644 -fn fix<F>(f: &F) - where F: Fn(&F) -{ - f(&f); -} - -fn main() { - fix(&|y| { - // Here, when `x` is called, the parameter `y` is equal to `x`. - }); -} -``` - -Rust does not permit a closure to directly reference its own type, -either through an argument (as in the example above) or by capturing -itself through its environment. This restriction helps keep closure -inference tractable. - -The easiest fix is to rewrite your closure into a top-level function, -or into a method. In some cases, you may also be able to have your -closure call itself by capturing a `&Fn()` object or `fn()` pointer -that refers to itself. That is permitting, since the closure would be -invoking itself via a virtual call, and hence does not directly -reference its own *type*. - -"##, - -E0692: r##" -A `repr(transparent)` type was also annotated with other, incompatible -representation hints. - -Erroneous code example: - -```compile_fail,E0692 -#[repr(transparent, C)] // error: incompatible representation hints -struct Grams(f32); -``` - -A type annotated as `repr(transparent)` delegates all representation concerns to -another type, so adding more representation hints is contradictory. Remove -either the `transparent` hint or the other hints, like this: - -``` -#[repr(transparent)] -struct Grams(f32); -``` - -Alternatively, move the other attributes to the contained type: - -``` -#[repr(C)] -struct Foo { - x: i32, - // ... -} - -#[repr(transparent)] -struct FooWrapper(Foo); -``` - -Note that introducing another `struct` just to have a place for the other -attributes may have unintended side effects on the representation: - -``` -#[repr(transparent)] -struct Grams(f32); - -#[repr(C)] -struct Float(f32); - -#[repr(transparent)] -struct Grams2(Float); // this is not equivalent to `Grams` above -``` - -Here, `Grams2` is a not equivalent to `Grams` -- the former transparently wraps -a (non-transparent) struct containing a single float, while `Grams` is a -transparent wrapper around a float. This can make a difference for the ABI. -"##, - -E0697: r##" -A closure has been used as `static`. - -Erroneous code example: - -```compile_fail,E0697 -fn main() { - static || {}; // used as `static` -} -``` - -Closures cannot be used as `static`. They "save" the environment, -and as such a static closure would save only a static environment -which would consist only of variables with a static lifetime. Given -this it would be better to use a proper function. The easiest fix -is to remove the `static` keyword. -"##, - -E0698: r##" -When using generators (or async) all type variables must be bound so a -generator can be constructed. - -Erroneous code example: - -```edition2018,compile-fail,E0698 -async fn bar<T>() -> () {} - -async fn foo() { - bar().await; // error: cannot infer type for `T` -} -``` - -In the above example `T` is unknowable by the compiler. -To fix this you must bind `T` to a concrete type such as `String` -so that a generator can then be constructed: - -```edition2018 -async fn bar<T>() -> () {} - -async fn foo() { - bar::<String>().await; - // ^^^^^^^^ specify type explicitly -} -``` -"##, - -E0700: r##" -The `impl Trait` return type captures lifetime parameters that do not -appear within the `impl Trait` itself. - -Erroneous code example: - -```compile-fail,E0700 -use std::cell::Cell; - -trait Trait<'a> { } - -impl<'a, 'b> Trait<'b> for Cell<&'a u32> { } - -fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y> -where 'x: 'y -{ - x -} -``` - -Here, the function `foo` returns a value of type `Cell<&'x u32>`, -which references the lifetime `'x`. However, the return type is -declared as `impl Trait<'y>` -- this indicates that `foo` returns -"some type that implements `Trait<'y>`", but it also indicates that -the return type **only captures data referencing the lifetime `'y`**. -In this case, though, we are referencing data with lifetime `'x`, so -this function is in error. - -To fix this, you must reference the lifetime `'x` from the return -type. For example, changing the return type to `impl Trait<'y> + 'x` -would work: - -``` -use std::cell::Cell; - -trait Trait<'a> { } - -impl<'a,'b> Trait<'b> for Cell<&'a u32> { } - -fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y> + 'x -where 'x: 'y -{ - x -} -``` -"##, - -E0701: r##" -This error indicates that a `#[non_exhaustive]` attribute was incorrectly placed -on something other than a struct or enum. - -Examples of erroneous code: - -```compile_fail,E0701 -#[non_exhaustive] -trait Foo { } -``` -"##, - -E0718: r##" -This error indicates that a `#[lang = ".."]` attribute was placed -on the wrong type of item. - -Examples of erroneous code: - -```compile_fail,E0718 -#![feature(lang_items)] - -#[lang = "arc"] -static X: u32 = 42; -``` -"##, - -E0728: r##" -[`await`] has been used outside [`async`] function or block. - -Erroneous code examples: - -```edition2018,compile_fail,E0728 -# use std::pin::Pin; -# use std::future::Future; -# use std::task::{Context, Poll}; -# -# struct WakeOnceThenComplete(bool); -# -# fn wake_and_yield_once() -> WakeOnceThenComplete { -# WakeOnceThenComplete(false) -# } -# -# impl Future for WakeOnceThenComplete { -# type Output = (); -# fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> { -# if self.0 { -# Poll::Ready(()) -# } else { -# cx.waker().wake_by_ref(); -# self.0 = true; -# Poll::Pending -# } -# } -# } -# -fn foo() { - wake_and_yield_once().await // `await` is used outside `async` context -} -``` - -[`await`] is used to suspend the current computation until the given -future is ready to produce a value. So it is legal only within -an [`async`] context, like an `async fn` or an `async` block. - -```edition2018 -# use std::pin::Pin; -# use std::future::Future; -# use std::task::{Context, Poll}; -# -# struct WakeOnceThenComplete(bool); -# -# fn wake_and_yield_once() -> WakeOnceThenComplete { -# WakeOnceThenComplete(false) -# } -# -# impl Future for WakeOnceThenComplete { -# type Output = (); -# fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> { -# if self.0 { -# Poll::Ready(()) -# } else { -# cx.waker().wake_by_ref(); -# self.0 = true; -# Poll::Pending -# } -# } -# } -# -async fn foo() { - wake_and_yield_once().await // `await` is used within `async` function -} - -fn bar(x: u8) -> impl Future<Output = u8> { - async move { - wake_and_yield_once().await; // `await` is used within `async` block - x - } -} -``` - -[`async`]: https://doc.rust-lang.org/std/keyword.async.html -[`await`]: https://doc.rust-lang.org/std/keyword.await.html -"##, - -E0734: r##" -A stability attribute has been used outside of the standard library. - -Erroneous code examples: - -```compile_fail,E0734 -#[rustc_deprecated(since = "b", reason = "text")] // invalid -#[stable(feature = "a", since = "b")] // invalid -#[unstable(feature = "b", issue = "0")] // invalid -fn foo(){} -``` - -These attributes are meant to only be used by the standard library and are -rejected in your own crates. -"##, - -E0736: r##" -`#[track_caller]` and `#[naked]` cannot both be applied to the same function. - -Erroneous code example: - -```compile_fail,E0736 -#![feature(track_caller)] - -#[naked] -#[track_caller] -fn foo() {} -``` - -This is primarily due to ABI incompatibilities between the two attributes. -See [RFC 2091] for details on this and other limitations. - -[RFC 2091]: https://github.com/rust-lang/rfcs/blob/master/text/2091-inline-semantic.md -"##, - -E0738: r##" -`#[track_caller]` cannot be used in traits yet. This is due to limitations in -the compiler which are likely to be temporary. See [RFC 2091] for details on -this and other restrictions. - -Erroneous example with a trait method implementation: - -```compile_fail,E0738 -#![feature(track_caller)] - -trait Foo { - fn bar(&self); -} - -impl Foo for u64 { - #[track_caller] - fn bar(&self) {} -} -``` - -Erroneous example with a blanket trait method implementation: - -```compile_fail,E0738 -#![feature(track_caller)] - -trait Foo { - #[track_caller] - fn bar(&self) {} - fn baz(&self); -} -``` - -Erroneous example with a trait method declaration: - -```compile_fail,E0738 -#![feature(track_caller)] - -trait Foo { - fn bar(&self) {} - - #[track_caller] - fn baz(&self); -} -``` - -Note that while the compiler may be able to support the attribute in traits in -the future, [RFC 2091] prohibits their implementation without a follow-up RFC. - -[RFC 2091]: https://github.com/rust-lang/rfcs/blob/master/text/2091-inline-semantic.md -"##, - -; -// E0006, // merged with E0005 -// E0101, // replaced with E0282 -// E0102, // replaced with E0282 -// E0134, -// E0135, -// E0272, // on_unimplemented #0 -// E0273, // on_unimplemented #1 -// E0274, // on_unimplemented #2 -// E0278, // requirement is not satisfied - E0279, // requirement is not satisfied - E0280, // requirement is not satisfied -// E0285, // overflow evaluation builtin bounds -// E0296, // replaced with a generic attribute input check -// E0300, // unexpanded macro -// E0304, // expected signed integer constant -// E0305, // expected constant - E0311, // thing may not live long enough - E0313, // lifetime of borrowed pointer outlives lifetime of captured - // variable - E0314, // closure outlives stack frame - E0315, // cannot invoke closure outside of its lifetime - E0316, // nested quantification of lifetimes - E0320, // recursive overflow during dropck - E0473, // dereference of reference outside its lifetime - E0474, // captured variable `..` does not outlive the enclosing closure - E0475, // index of slice outside its lifetime - E0476, // lifetime of the source pointer does not outlive lifetime bound... - E0477, // the type `..` does not fulfill the required lifetime... - E0479, // the type `..` (provided as the value of a type parameter) is... - E0480, // lifetime of method receiver does not outlive the method call - E0481, // lifetime of function argument does not outlive the function call - E0482, // lifetime of return value does not outlive the function call - E0483, // lifetime of operand does not outlive the operation - E0484, // reference is not valid at the time of borrow - E0485, // automatically reference is not valid at the time of borrow - E0486, // type of expression contains references that are not valid during.. - E0487, // unsafe use of destructor: destructor might be called while... - E0488, // lifetime of variable does not enclose its declaration - E0489, // type/lifetime parameter not in scope here - E0490, // a value of type `..` is borrowed for too long - E0628, // generators cannot have explicit parameters - E0631, // type mismatch in closure arguments - E0637, // "'_" is not a valid lifetime bound - E0657, // `impl Trait` can only capture lifetimes bound at the fn level - E0687, // in-band lifetimes cannot be used in `fn`/`Fn` syntax - E0688, // in-band lifetimes cannot be mixed with explicit lifetime binders - E0703, // invalid ABI -// E0707, // multiple elided lifetimes used in arguments of `async fn` - E0708, // `async` non-`move` closures with parameters are not currently - // supported -// E0709, // multiple different lifetimes used in arguments of `async fn` - E0710, // an unknown tool name found in scoped lint - E0711, // a feature has been declared with conflicting stability attributes -// E0702, // replaced with a generic attribute input check - E0726, // non-explicit (not `'_`) elided lifetime in unsupported position - E0727, // `async` generators are not yet supported - E0739, // invalid track_caller application/syntax -} diff --git a/src/librustc/hir/check_attr.rs b/src/librustc/hir/check_attr.rs index 96562002aa0..ea1c585176d 100644 --- a/src/librustc/hir/check_attr.rs +++ b/src/librustc/hir/check_attr.rs @@ -16,6 +16,8 @@ use std::fmt::{self, Display}; use syntax::{attr, symbol::sym}; use syntax_pos::Span; +use rustc_error_codes::*; + #[derive(Copy, Clone, PartialEq)] pub(crate) enum MethodKind { Trait { body: bool }, diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 2c8e14f2add..9c09ce99486 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -74,6 +74,8 @@ use syntax::visit::{self, Visitor}; use syntax_pos::hygiene::ExpnId; use syntax_pos::Span; +use rustc_error_codes::*; + const HIR_ID_COUNTER_LOCKED: u32 = 0xFFFFFFFF; pub struct LoweringContext<'a> { diff --git a/src/librustc/hir/lowering/expr.rs b/src/librustc/hir/lowering/expr.rs index 62f3eaef244..d5d3ff0db2e 100644 --- a/src/librustc/hir/lowering/expr.rs +++ b/src/librustc/hir/lowering/expr.rs @@ -11,6 +11,8 @@ use syntax::ast::*; use syntax::source_map::{respan, DesugaringKind, Span, Spanned}; use syntax::symbol::{sym, Symbol}; +use rustc_error_codes::*; + impl LoweringContext<'_> { fn lower_exprs(&mut self, exprs: &[AstP<Expr>]) -> HirVec<hir::Expr> { exprs.iter().map(|x| self.lower_expr(x)).collect() diff --git a/src/librustc/hir/lowering/item.rs b/src/librustc/hir/lowering/item.rs index aafdd78e3e8..137d21c3580 100644 --- a/src/librustc/hir/lowering/item.rs +++ b/src/librustc/hir/lowering/item.rs @@ -23,6 +23,8 @@ use syntax::source_map::{respan, DesugaringKind}; use syntax::symbol::{kw, sym}; use syntax_pos::Span; +use rustc_error_codes::*; + pub(super) struct ItemLowerer<'tcx, 'interner> { pub(super) lctx: &'tcx mut LoweringContext<'interner>, } diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs index 38edef50c96..d0f6a8a434d 100644 --- a/src/librustc/infer/error_reporting/mod.rs +++ b/src/librustc/infer/error_reporting/mod.rs @@ -63,6 +63,8 @@ use errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString}; use std::{cmp, fmt}; use syntax_pos::{Pos, Span}; +use rustc_error_codes::*; + mod note; mod need_type_info; diff --git a/src/librustc/infer/error_reporting/need_type_info.rs b/src/librustc/infer/error_reporting/need_type_info.rs index b89731273f7..32eecdf01a3 100644 --- a/src/librustc/infer/error_reporting/need_type_info.rs +++ b/src/librustc/infer/error_reporting/need_type_info.rs @@ -9,6 +9,8 @@ use syntax::source_map::DesugaringKind; use syntax_pos::Span; use errors::{Applicability, DiagnosticBuilder}; +use rustc_error_codes::*; + struct FindLocalByTypeVisitor<'a, 'tcx> { infcx: &'a InferCtxt<'a, 'tcx>, target_ty: Ty<'tcx>, diff --git a/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs b/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs index 979815fa7f1..d7cba87e6b1 100644 --- a/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs +++ b/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs @@ -5,6 +5,8 @@ use crate::infer::error_reporting::nice_region_error::NiceRegionError; use crate::infer::error_reporting::nice_region_error::util::AnonymousParamInfo; use crate::util::common::ErrorReported; +use rustc_error_codes::*; + impl<'a, 'tcx> NiceRegionError<'a, 'tcx> { /// Print the error message for lifetime errors when both the concerned regions are anonymous. /// diff --git a/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs b/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs index a9a2c15d7d9..36131849191 100644 --- a/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs +++ b/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs @@ -5,6 +5,8 @@ use crate::hir::{FunctionRetTy, TyKind}; use crate::ty; use errors::{Applicability, DiagnosticBuilder}; +use rustc_error_codes::*; + impl<'a, 'tcx> NiceRegionError<'a, 'tcx> { /// When given a `ConcreteFailure` for a function with parameters containing a named region and /// an anonymous region, emit an descriptive diagnostic error. diff --git a/src/librustc/infer/error_reporting/note.rs b/src/librustc/infer/error_reporting/note.rs index 115ffea97bf..c1f840ad678 100644 --- a/src/librustc/infer/error_reporting/note.rs +++ b/src/librustc/infer/error_reporting/note.rs @@ -4,6 +4,8 @@ use crate::ty::{self, Region}; use crate::ty::error::TypeError; use errors::DiagnosticBuilder; +use rustc_error_codes::*; + impl<'a, 'tcx> InferCtxt<'a, 'tcx> { pub(super) fn note_region_origin(&self, err: &mut DiagnosticBuilder<'_>, diff --git a/src/librustc/infer/opaque_types/mod.rs b/src/librustc/infer/opaque_types/mod.rs index dc54a273ed0..9ed60b1f0c1 100644 --- a/src/librustc/infer/opaque_types/mod.rs +++ b/src/librustc/infer/opaque_types/mod.rs @@ -15,6 +15,8 @@ use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::sync::Lrc; use syntax_pos::Span; +use rustc_error_codes::*; + pub type OpaqueTypeMap<'tcx> = DefIdMap<OpaqueTypeDecl<'tcx>>; /// Information about the opaque types whose values we diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index 7dbacfd133f..82994f9170f 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -83,8 +83,6 @@ mod tests; #[macro_use] mod macros; -pub mod error_codes; - #[macro_use] pub mod query; diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index dc3bc5fa0ce..2f865f1f8b5 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -40,6 +40,8 @@ use syntax::util::lev_distance::find_best_match_for_name; use syntax::visit as ast_visit; use syntax_pos::{MultiSpan, Span, symbol::Symbol}; +use rustc_error_codes::*; + /// Information about the registered lints. /// /// This is basically the subset of `Context` that we can diff --git a/src/librustc/lint/levels.rs b/src/librustc/lint/levels.rs index e470dbdf323..27bf9649324 100644 --- a/src/librustc/lint/levels.rs +++ b/src/librustc/lint/levels.rs @@ -16,6 +16,8 @@ use syntax::print::pprust; use syntax::source_map::MultiSpan; use syntax::symbol::{Symbol, sym}; +use rustc_error_codes::*; + pub struct LintLevelSets { list: Vec<LintSet>, lint_cap: Level, diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 41f02a876f5..f6cd9b1c7ec 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -23,6 +23,8 @@ use rustc_macros::HashStable; use crate::hir::itemlikevisit::ItemLikeVisitor; use crate::hir; +use rustc_error_codes::*; + // The actual lang items defined come at the end of this file in one handy table. // So you probably just want to nip down to the end. macro_rules! language_item_table { diff --git a/src/librustc/middle/lib_features.rs b/src/librustc/middle/lib_features.rs index 2d726fcd176..e6f8521216b 100644 --- a/src/librustc/middle/lib_features.rs +++ b/src/librustc/middle/lib_features.rs @@ -11,7 +11,8 @@ use syntax::ast::{Attribute, MetaItem, MetaItemKind}; use syntax_pos::{Span, sym}; use rustc_data_structures::fx::{FxHashSet, FxHashMap}; use rustc_macros::HashStable; -use errors::DiagnosticId; + +use rustc_error_codes::*; #[derive(HashStable)] pub struct LibFeatures { @@ -98,15 +99,16 @@ impl LibFeatureCollector<'tcx> { (Some(since), _, false) => { if let Some(prev_since) = self.lib_features.stable.get(&feature) { if *prev_since != since { - let msg = format!( - "feature `{}` is declared stable since {}, \ - but was previously declared stable since {}", - feature, - since, - prev_since, + self.span_feature_error( + span, + &format!( + "feature `{}` is declared stable since {}, \ + but was previously declared stable since {}", + feature, + since, + prev_since, + ), ); - self.tcx.sess.struct_span_err_with_code(span, &msg, - DiagnosticId::Error("E0711".into())).emit(); return; } } @@ -117,17 +119,27 @@ impl LibFeatureCollector<'tcx> { self.lib_features.unstable.insert(feature); } (Some(_), _, true) | (None, true, _) => { - let msg = format!( - "feature `{}` is declared {}, but was previously declared {}", - feature, - if since.is_some() { "stable" } else { "unstable" }, - if since.is_none() { "stable" } else { "unstable" }, + self.span_feature_error( + span, + &format!( + "feature `{}` is declared {}, but was previously declared {}", + feature, + if since.is_some() { "stable" } else { "unstable" }, + if since.is_none() { "stable" } else { "unstable" }, + ), ); - self.tcx.sess.struct_span_err_with_code(span, &msg, - DiagnosticId::Error("E0711".into())).emit(); } } } + + fn span_feature_error(&self, span: Span, msg: &str) { + struct_span_err!( + self.tcx.sess, + span, + E0711, + "{}", &msg, + ).emit(); + } } impl Visitor<'tcx> for LibFeatureCollector<'tcx> { diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index f37d9b2827b..a70fe2be96c 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -30,6 +30,8 @@ use syntax_pos::Span; use crate::hir::intravisit::{self, NestedVisitorMap, Visitor}; use crate::hir::{self, GenericParamKind, LifetimeParamKind}; +use rustc_error_codes::*; + /// The origin of a named lifetime definition. /// /// This is used to prevent the usage of in-band lifetimes in `Fn`/`fn` syntax. diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index fabb0a59da8..8f8b4ed98bd 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -26,6 +26,9 @@ use std::cmp::Ordering; use std::mem::replace; use std::num::NonZeroU32; +use rustc_error_codes::*; + + #[derive(PartialEq, Clone, Copy, Debug)] pub enum StabilityLevel { Unstable, diff --git a/src/librustc/middle/weak_lang_items.rs b/src/librustc/middle/weak_lang_items.rs index fa5fa2257db..48c1226232f 100644 --- a/src/librustc/middle/weak_lang_items.rs +++ b/src/librustc/middle/weak_lang_items.rs @@ -14,6 +14,8 @@ use crate::hir::intravisit; use crate::hir; use crate::ty::TyCtxt; +use rustc_error_codes::*; + macro_rules! weak_lang_items { ($($name:ident, $item:ident, $sym:ident;)*) => ( diff --git a/src/librustc/mir/interpret/error.rs b/src/librustc/mir/interpret/error.rs index d918b9ee673..5f605756438 100644 --- a/src/librustc/mir/interpret/error.rs +++ b/src/librustc/mir/interpret/error.rs @@ -16,6 +16,8 @@ use syntax::symbol::Symbol; use std::{fmt, env}; +use rustc_error_codes::*; + #[derive(Debug, Copy, Clone, PartialEq, Eq, HashStable, RustcEncodable, RustcDecodable)] pub enum ErrorHandled { /// Already reported a lint or an error for this evaluation. diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs index f77db962135..82631ce7435 100644 --- a/src/librustc/traits/error_reporting.rs +++ b/src/librustc/traits/error_reporting.rs @@ -39,6 +39,8 @@ use syntax::ast; use syntax::symbol::{sym, kw}; use syntax_pos::{DUMMY_SP, Span, ExpnKind, MultiSpan}; +use rustc_error_codes::*; + impl<'a, 'tcx> InferCtxt<'a, 'tcx> { pub fn report_fulfillment_errors( &self, diff --git a/src/librustc/traits/on_unimplemented.rs b/src/librustc/traits/on_unimplemented.rs index b64e44b6a5a..59aa0810975 100644 --- a/src/librustc/traits/on_unimplemented.rs +++ b/src/librustc/traits/on_unimplemented.rs @@ -10,6 +10,8 @@ use syntax::attr; use syntax::symbol::{Symbol, kw, sym}; use syntax_pos::Span; +use rustc_error_codes::*; + #[derive(Clone, Debug)] pub struct OnUnimplementedFormatString(Symbol); diff --git a/src/librustc/traits/query/dropck_outlives.rs b/src/librustc/traits/query/dropck_outlives.rs index eaf5971e459..9a9c8e9d0d3 100644 --- a/src/librustc/traits/query/dropck_outlives.rs +++ b/src/librustc/traits/query/dropck_outlives.rs @@ -6,6 +6,8 @@ use syntax::source_map::Span; use crate::ty::subst::GenericArg; use crate::ty::{self, Ty, TyCtxt}; +use rustc_error_codes::*; + impl<'cx, 'tcx> At<'cx, 'tcx> { /// Given a type `ty` of some value being dropped, computes a set /// of "kinds" (types, regions) that must be outlive the execution diff --git a/src/librustc/traits/specialize/mod.rs b/src/librustc/traits/specialize/mod.rs index c1c6eb850f5..475037f54ba 100644 --- a/src/librustc/traits/specialize/mod.rs +++ b/src/librustc/traits/specialize/mod.rs @@ -24,6 +24,8 @@ use crate::ty::subst::{Subst, InternalSubsts, SubstsRef}; use super::{SelectionContext, FulfillmentContext}; use super::util::impl_trait_ref_and_oblig; +use rustc_error_codes::*; + /// Information pertinent to an overlapping impl error. #[derive(Debug)] pub struct OverlapError { diff --git a/src/librustc/ty/query/plumbing.rs b/src/librustc/ty/query/plumbing.rs index 1c15b7d5f35..214de35b6d0 100644 --- a/src/librustc/ty/query/plumbing.rs +++ b/src/librustc/ty/query/plumbing.rs @@ -26,6 +26,8 @@ use std::collections::hash_map::Entry; use syntax_pos::Span; use syntax::source_map::DUMMY_SP; +use rustc_error_codes::*; + pub struct QueryCache<'tcx, D: QueryConfig<'tcx> + ?Sized> { pub(super) results: FxHashMap<D::Key, QueryValue<D::Value>>, pub(super) active: FxHashMap<D::Key, QueryResult<'tcx>>, diff --git a/src/librustc_codegen_ssa/Cargo.toml b/src/librustc_codegen_ssa/Cargo.toml index 2eaae505916..478c3a9084c 100644 --- a/src/librustc_codegen_ssa/Cargo.toml +++ b/src/librustc_codegen_ssa/Cargo.toml @@ -31,3 +31,4 @@ rustc_fs_util = { path = "../librustc_fs_util" } rustc_incremental = { path = "../librustc_incremental" } rustc_index = { path = "../librustc_index" } rustc_target = { path = "../librustc_target" } +rustc_error_codes = { path = "../librustc_error_codes" } diff --git a/src/librustc_codegen_ssa/common.rs b/src/librustc_codegen_ssa/common.rs index ac39ca98476..9bebca93964 100644 --- a/src/librustc_codegen_ssa/common.rs +++ b/src/librustc_codegen_ssa/common.rs @@ -12,6 +12,8 @@ use crate::traits::*; use rustc::hir; use crate::traits::BuilderMethods; +use rustc_error_codes::*; + pub enum IntPredicate { IntEQ, IntNE, diff --git a/src/librustc_codegen_ssa/error_codes.rs b/src/librustc_codegen_ssa/error_codes.rs deleted file mode 100644 index 02e26d8f6ec..00000000000 --- a/src/librustc_codegen_ssa/error_codes.rs +++ /dev/null @@ -1,71 +0,0 @@ -syntax::register_diagnostics! { - -E0511: r##" -Invalid monomorphization of an intrinsic function was used. Erroneous code -example: - -```ignore (error-emitted-at-codegen-which-cannot-be-handled-by-compile_fail) -#![feature(platform_intrinsics)] - -extern "platform-intrinsic" { - fn simd_add<T>(a: T, b: T) -> T; -} - -fn main() { - unsafe { simd_add(0, 1); } - // error: invalid monomorphization of `simd_add` intrinsic -} -``` - -The generic type has to be a SIMD type. Example: - -``` -#![feature(repr_simd)] -#![feature(platform_intrinsics)] - -#[repr(simd)] -#[derive(Copy, Clone)] -struct i32x2(i32, i32); - -extern "platform-intrinsic" { - fn simd_add<T>(a: T, b: T) -> T; -} - -unsafe { simd_add(i32x2(0, 0), i32x2(1, 2)); } // ok! -``` -"##, - -E0668: r##" -Malformed inline assembly rejected by LLVM. - -LLVM checks the validity of the constraints and the assembly string passed to -it. This error implies that LLVM seems something wrong with the inline -assembly call. - -In particular, it can happen if you forgot the closing bracket of a register -constraint (see issue #51430): -```ignore (error-emitted-at-codegen-which-cannot-be-handled-by-compile_fail) -#![feature(asm)] - -fn main() { - let rax: u64; - unsafe { - asm!("" :"={rax"(rax)); - println!("Accumulator is: {}", rax); - } -} -``` -"##, - -E0669: r##" -Cannot convert inline assembly operand to a single LLVM value. - -This error usually happens when trying to pass in a value to an input inline -assembly operand that is actually a pair of values. In particular, this can -happen when trying to pass in a slice, for instance a `&str`. In Rust, these -values are represented internally as a pair of values, the pointer and its -length. When passed as an input operand, this pair of values can not be -coerced into a register and thus we must fail with an error. -"##, - -} diff --git a/src/librustc_codegen_ssa/lib.rs b/src/librustc_codegen_ssa/lib.rs index 81e7ef64e97..9784d870b31 100644 --- a/src/librustc_codegen_ssa/lib.rs +++ b/src/librustc_codegen_ssa/lib.rs @@ -35,8 +35,6 @@ use rustc::middle::cstore::{LibSource, CrateSource, NativeLibrary}; use rustc::middle::dependency_format::Dependencies; use syntax_pos::symbol::Symbol; -mod error_codes; - pub mod common; pub mod traits; pub mod mir; diff --git a/src/librustc_codegen_ssa/mir/statement.rs b/src/librustc_codegen_ssa/mir/statement.rs index d11601be0b4..0b82edea157 100644 --- a/src/librustc_codegen_ssa/mir/statement.rs +++ b/src/librustc_codegen_ssa/mir/statement.rs @@ -6,6 +6,8 @@ use super::LocalRef; use super::OperandValue; use crate::traits::*; +use rustc_error_codes::*; + impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { pub fn codegen_statement( &mut self, diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 514c6d0e1da..d4f796ee3a7 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -524,13 +524,13 @@ fn handle_explain(code: &str, let mut text = String::new(); // Slice off the leading newline and print. - for line in description[1..].lines() { + for line in description.lines() { let indent_level = line.find(|c: char| !c.is_whitespace()) .unwrap_or_else(|| line.len()); let dedented_line = &line[indent_level..]; if dedented_line.starts_with("```") { is_in_code_block = !is_in_code_block; - text.push_str(&line[..(indent_level+3)]); + text.push_str(&line[..(indent_level + 3)]); } else if is_in_code_block && dedented_line.starts_with("# ") { continue; } else { diff --git a/src/librustc_error_codes/Cargo.toml b/src/librustc_error_codes/Cargo.toml new file mode 100644 index 00000000000..5def867ff11 --- /dev/null +++ b/src/librustc_error_codes/Cargo.toml @@ -0,0 +1,9 @@ +[package] +authors = ["The Rust Project Developers"] +name = "rustc_error_codes" +version = "0.0.0" +edition = "2018" + +[lib] +name = "rustc_error_codes" +path = "lib.rs" diff --git a/src/librustc_error_codes/error_codes.rs b/src/librustc_error_codes/error_codes.rs new file mode 100644 index 00000000000..5e6d5ce159d --- /dev/null +++ b/src/librustc_error_codes/error_codes.rs @@ -0,0 +1,609 @@ +// Error messages for EXXXX errors. Each message should start and end with a +// new line, and be wrapped to 80 characters. In vim you can `:set tw=80` and +// use `gq` to wrap paragraphs. Use `:set tw=0` to disable. + +crate::register_diagnostics! { + +E0001: include_str!("./error_codes/E0001.md"), +E0002: include_str!("./error_codes/E0002.md"), +E0004: include_str!("./error_codes/E0004.md"), +E0005: include_str!("./error_codes/E0005.md"), +E0007: include_str!("./error_codes/E0007.md"), +E0009: include_str!("./error_codes/E0009.md"), +E0010: include_str!("./error_codes/E0010.md"), +E0013: include_str!("./error_codes/E0013.md"), +E0014: include_str!("./error_codes/E0014.md"), +E0015: include_str!("./error_codes/E0015.md"), +E0017: include_str!("./error_codes/E0017.md"), +E0019: include_str!("./error_codes/E0019.md"), +E0023: include_str!("./error_codes/E0023.md"), +E0025: include_str!("./error_codes/E0025.md"), +E0026: include_str!("./error_codes/E0026.md"), +E0027: include_str!("./error_codes/E0027.md"), +E0029: include_str!("./error_codes/E0029.md"), +E0030: include_str!("./error_codes/E0030.md"), +E0033: include_str!("./error_codes/E0033.md"), +E0034: include_str!("./error_codes/E0034.md"), +E0038: include_str!("./error_codes/E0038.md"), +E0040: include_str!("./error_codes/E0040.md"), +E0044: include_str!("./error_codes/E0044.md"), +E0045: include_str!("./error_codes/E0045.md"), +E0046: include_str!("./error_codes/E0046.md"), +E0049: include_str!("./error_codes/E0049.md"), +E0050: include_str!("./error_codes/E0050.md"), +E0053: include_str!("./error_codes/E0053.md"), +E0054: include_str!("./error_codes/E0054.md"), +E0055: include_str!("./error_codes/E0055.md"), +E0057: include_str!("./error_codes/E0057.md"), +E0059: include_str!("./error_codes/E0059.md"), +E0060: include_str!("./error_codes/E0060.md"), +E0061: include_str!("./error_codes/E0061.md"), +E0062: include_str!("./error_codes/E0062.md"), +E0063: include_str!("./error_codes/E0063.md"), +E0067: include_str!("./error_codes/E0067.md"), +E0069: include_str!("./error_codes/E0069.md"), +E0070: include_str!("./error_codes/E0070.md"), +E0071: include_str!("./error_codes/E0071.md"), +E0072: include_str!("./error_codes/E0072.md"), +E0073: include_str!("./error_codes/E0073.md"), +E0074: include_str!("./error_codes/E0074.md"), +E0075: include_str!("./error_codes/E0075.md"), +E0076: include_str!("./error_codes/E0076.md"), +E0077: include_str!("./error_codes/E0077.md"), +E0080: include_str!("./error_codes/E0080.md"), +E0081: include_str!("./error_codes/E0081.md"), +E0084: include_str!("./error_codes/E0084.md"), +E0087: include_str!("./error_codes/E0087.md"), +E0088: include_str!("./error_codes/E0088.md"), +E0089: include_str!("./error_codes/E0089.md"), +E0090: include_str!("./error_codes/E0090.md"), +E0091: include_str!("./error_codes/E0091.md"), +E0092: include_str!("./error_codes/E0092.md"), +E0093: include_str!("./error_codes/E0093.md"), +E0094: include_str!("./error_codes/E0094.md"), +E0106: include_str!("./error_codes/E0106.md"), +E0107: include_str!("./error_codes/E0107.md"), +E0109: include_str!("./error_codes/E0109.md"), +E0110: include_str!("./error_codes/E0110.md"), +E0116: include_str!("./error_codes/E0116.md"), +E0117: include_str!("./error_codes/E0117.md"), +E0118: include_str!("./error_codes/E0118.md"), +E0119: include_str!("./error_codes/E0119.md"), +E0120: include_str!("./error_codes/E0120.md"), +E0121: include_str!("./error_codes/E0121.md"), +E0124: include_str!("./error_codes/E0124.md"), +E0128: include_str!("./error_codes/E0128.md"), +E0130: include_str!("./error_codes/E0130.md"), +E0131: include_str!("./error_codes/E0131.md"), +E0132: include_str!("./error_codes/E0132.md"), +E0133: include_str!("./error_codes/E0133.md"), +E0136: include_str!("./error_codes/E0136.md"), +E0137: include_str!("./error_codes/E0137.md"), +E0138: include_str!("./error_codes/E0138.md"), +E0139: include_str!("./error_codes/E0139.md"), +E0152: include_str!("./error_codes/E0152.md"), +E0154: include_str!("./error_codes/E0154.md"), +E0158: include_str!("./error_codes/E0158.md"), +E0161: include_str!("./error_codes/E0161.md"), +E0162: include_str!("./error_codes/E0162.md"), +E0164: include_str!("./error_codes/E0164.md"), +E0165: include_str!("./error_codes/E0165.md"), +E0170: include_str!("./error_codes/E0170.md"), +E0178: include_str!("./error_codes/E0178.md"), +E0184: include_str!("./error_codes/E0184.md"), +E0185: include_str!("./error_codes/E0185.md"), +E0186: include_str!("./error_codes/E0186.md"), +E0191: include_str!("./error_codes/E0191.md"), +E0192: include_str!("./error_codes/E0192.md"), +E0193: include_str!("./error_codes/E0193.md"), +E0195: include_str!("./error_codes/E0195.md"), +E0197: include_str!("./error_codes/E0197.md"), +E0198: include_str!("./error_codes/E0198.md"), +E0199: include_str!("./error_codes/E0199.md"), +E0200: include_str!("./error_codes/E0200.md"), +E0201: include_str!("./error_codes/E0201.md"), +E0202: include_str!("./error_codes/E0202.md"), +E0204: include_str!("./error_codes/E0204.md"), +E0205: include_str!("./error_codes/E0205.md"), +E0206: include_str!("./error_codes/E0206.md"), +E0207: include_str!("./error_codes/E0207.md"), +E0210: include_str!("./error_codes/E0210.md"), +E0211: include_str!("./error_codes/E0211.md"), +E0214: include_str!("./error_codes/E0214.md"), +E0220: include_str!("./error_codes/E0220.md"), +E0221: include_str!("./error_codes/E0221.md"), +E0223: include_str!("./error_codes/E0223.md"), +E0225: include_str!("./error_codes/E0225.md"), +E0229: include_str!("./error_codes/E0229.md"), +E0230: include_str!("./error_codes/E0230.md"), +E0231: include_str!("./error_codes/E0231.md"), +E0232: include_str!("./error_codes/E0232.md"), +E0243: include_str!("./error_codes/E0243.md"), +E0244: include_str!("./error_codes/E0244.md"), +E0251: include_str!("./error_codes/E0251.md"), +E0252: include_str!("./error_codes/E0252.md"), +E0253: include_str!("./error_codes/E0253.md"), +E0254: include_str!("./error_codes/E0254.md"), +E0255: include_str!("./error_codes/E0255.md"), +E0256: include_str!("./error_codes/E0256.md"), +E0259: include_str!("./error_codes/E0259.md"), +E0260: include_str!("./error_codes/E0260.md"), +E0261: include_str!("./error_codes/E0261.md"), +E0262: include_str!("./error_codes/E0262.md"), +E0263: include_str!("./error_codes/E0263.md"), +E0264: include_str!("./error_codes/E0264.md"), +E0267: include_str!("./error_codes/E0267.md"), +E0268: include_str!("./error_codes/E0268.md"), +E0271: include_str!("./error_codes/E0271.md"), +E0275: include_str!("./error_codes/E0275.md"), +E0276: include_str!("./error_codes/E0276.md"), +E0277: include_str!("./error_codes/E0277.md"), +E0281: include_str!("./error_codes/E0281.md"), +E0282: include_str!("./error_codes/E0282.md"), +E0283: include_str!("./error_codes/E0283.md"), +E0284: include_str!("./error_codes/E0284.md"), +E0297: include_str!("./error_codes/E0297.md"), +E0301: include_str!("./error_codes/E0301.md"), +E0302: include_str!("./error_codes/E0302.md"), +E0303: include_str!("./error_codes/E0303.md"), +E0307: include_str!("./error_codes/E0307.md"), +E0308: include_str!("./error_codes/E0308.md"), +E0309: include_str!("./error_codes/E0309.md"), +E0310: include_str!("./error_codes/E0310.md"), +E0312: include_str!("./error_codes/E0312.md"), +E0317: include_str!("./error_codes/E0317.md"), +E0321: include_str!("./error_codes/E0321.md"), +E0322: include_str!("./error_codes/E0322.md"), +E0323: include_str!("./error_codes/E0323.md"), +E0324: include_str!("./error_codes/E0324.md"), +E0325: include_str!("./error_codes/E0325.md"), +E0326: include_str!("./error_codes/E0326.md"), +E0328: include_str!("./error_codes/E0328.md"), +E0329: include_str!("./error_codes/E0329.md"), +E0364: include_str!("./error_codes/E0364.md"), +E0365: include_str!("./error_codes/E0365.md"), +E0366: include_str!("./error_codes/E0366.md"), +E0367: include_str!("./error_codes/E0367.md"), +E0368: include_str!("./error_codes/E0368.md"), +E0369: include_str!("./error_codes/E0369.md"), +E0370: include_str!("./error_codes/E0370.md"), +E0371: include_str!("./error_codes/E0371.md"), +E0373: include_str!("./error_codes/E0373.md"), +E0374: include_str!("./error_codes/E0374.md"), +E0375: include_str!("./error_codes/E0375.md"), +E0376: include_str!("./error_codes/E0376.md"), +E0378: include_str!("./error_codes/E0378.md"), +E0379: include_str!("./error_codes/E0379.md"), +E0380: include_str!("./error_codes/E0380.md"), +E0381: include_str!("./error_codes/E0381.md"), +E0382: include_str!("./error_codes/E0382.md"), +E0383: include_str!("./error_codes/E0383.md"), +E0384: include_str!("./error_codes/E0384.md"), +E0386: include_str!("./error_codes/E0386.md"), +E0387: include_str!("./error_codes/E0387.md"), +E0388: include_str!("./error_codes/E0388.md"), +E0389: include_str!("./error_codes/E0389.md"), +E0390: include_str!("./error_codes/E0390.md"), +E0391: include_str!("./error_codes/E0391.md"), +E0392: include_str!("./error_codes/E0392.md"), +E0393: include_str!("./error_codes/E0393.md"), +E0398: include_str!("./error_codes/E0398.md"), +E0399: include_str!("./error_codes/E0399.md"), +E0401: include_str!("./error_codes/E0401.md"), +E0403: include_str!("./error_codes/E0403.md"), +E0404: include_str!("./error_codes/E0404.md"), +E0405: include_str!("./error_codes/E0405.md"), +E0407: include_str!("./error_codes/E0407.md"), +E0408: include_str!("./error_codes/E0408.md"), +E0409: include_str!("./error_codes/E0409.md"), +E0411: include_str!("./error_codes/E0411.md"), +E0412: include_str!("./error_codes/E0412.md"), +E0415: include_str!("./error_codes/E0415.md"), +E0416: include_str!("./error_codes/E0416.md"), +E0422: include_str!("./error_codes/E0422.md"), +E0423: include_str!("./error_codes/E0423.md"), +E0424: include_str!("./error_codes/E0424.md"), +E0425: include_str!("./error_codes/E0425.md"), +E0426: include_str!("./error_codes/E0426.md"), +E0428: include_str!("./error_codes/E0428.md"), +E0429: include_str!("./error_codes/E0429.md"), +E0430: include_str!("./error_codes/E0430.md"), +E0431: include_str!("./error_codes/E0431.md"), +E0432: include_str!("./error_codes/E0432.md"), +E0433: include_str!("./error_codes/E0433.md"), +E0434: include_str!("./error_codes/E0434.md"), +E0435: include_str!("./error_codes/E0435.md"), +E0436: include_str!("./error_codes/E0436.md"), +E0437: include_str!("./error_codes/E0437.md"), +E0438: include_str!("./error_codes/E0438.md"), +E0439: include_str!("./error_codes/E0439.md"), +E0445: include_str!("./error_codes/E0445.md"), +E0446: include_str!("./error_codes/E0446.md"), +E0447: include_str!("./error_codes/E0447.md"), +E0448: include_str!("./error_codes/E0448.md"), +E0449: include_str!("./error_codes/E0449.md"), +E0451: include_str!("./error_codes/E0451.md"), +E0452: include_str!("./error_codes/E0452.md"), +E0453: include_str!("./error_codes/E0453.md"), +E0454: include_str!("./error_codes/E0454.md"), +E0455: include_str!("./error_codes/E0455.md"), +E0458: include_str!("./error_codes/E0458.md"), +E0459: include_str!("./error_codes/E0459.md"), +E0463: include_str!("./error_codes/E0463.md"), +E0466: include_str!("./error_codes/E0466.md"), +E0468: include_str!("./error_codes/E0468.md"), +E0469: include_str!("./error_codes/E0469.md"), +E0478: include_str!("./error_codes/E0478.md"), +E0491: include_str!("./error_codes/E0491.md"), +E0492: include_str!("./error_codes/E0492.md"), +E0493: include_str!("./error_codes/E0493.md"), +E0495: include_str!("./error_codes/E0495.md"), +E0496: include_str!("./error_codes/E0496.md"), +E0497: include_str!("./error_codes/E0497.md"), +E0499: include_str!("./error_codes/E0499.md"), +E0500: include_str!("./error_codes/E0500.md"), +E0501: include_str!("./error_codes/E0501.md"), +E0502: include_str!("./error_codes/E0502.md"), +E0503: include_str!("./error_codes/E0503.md"), +E0504: include_str!("./error_codes/E0504.md"), +E0505: include_str!("./error_codes/E0505.md"), +E0506: include_str!("./error_codes/E0506.md"), +E0507: include_str!("./error_codes/E0507.md"), +E0508: include_str!("./error_codes/E0508.md"), +E0509: include_str!("./error_codes/E0509.md"), +E0510: include_str!("./error_codes/E0510.md"), +E0511: include_str!("./error_codes/E0511.md"), +E0512: include_str!("./error_codes/E0512.md"), +E0515: include_str!("./error_codes/E0515.md"), +E0516: include_str!("./error_codes/E0516.md"), +E0517: include_str!("./error_codes/E0517.md"), +E0518: include_str!("./error_codes/E0518.md"), +E0520: include_str!("./error_codes/E0520.md"), +E0522: include_str!("./error_codes/E0522.md"), +E0524: include_str!("./error_codes/E0524.md"), +E0525: include_str!("./error_codes/E0525.md"), +E0527: include_str!("./error_codes/E0527.md"), +E0528: include_str!("./error_codes/E0528.md"), +E0529: include_str!("./error_codes/E0529.md"), +E0530: include_str!("./error_codes/E0530.md"), +E0531: include_str!("./error_codes/E0531.md"), +E0532: include_str!("./error_codes/E0532.md"), +E0533: include_str!("./error_codes/E0533.md"), +E0534: include_str!("./error_codes/E0534.md"), +E0535: include_str!("./error_codes/E0535.md"), +E0536: include_str!("./error_codes/E0536.md"), +E0537: include_str!("./error_codes/E0537.md"), +E0538: include_str!("./error_codes/E0538.md"), +E0541: include_str!("./error_codes/E0541.md"), +E0550: include_str!("./error_codes/E0550.md"), +E0551: include_str!("./error_codes/E0551.md"), +E0552: include_str!("./error_codes/E0552.md"), +E0554: include_str!("./error_codes/E0554.md"), +E0556: include_str!("./error_codes/E0556.md"), +E0557: include_str!("./error_codes/E0557.md"), +E0559: include_str!("./error_codes/E0559.md"), +E0560: include_str!("./error_codes/E0560.md"), +E0561: include_str!("./error_codes/E0561.md"), +E0562: include_str!("./error_codes/E0562.md"), +E0565: include_str!("./error_codes/E0565.md"), +E0566: include_str!("./error_codes/E0566.md"), +E0567: include_str!("./error_codes/E0567.md"), +E0568: include_str!("./error_codes/E0568.md"), +E0569: include_str!("./error_codes/E0569.md"), +E0570: include_str!("./error_codes/E0570.md"), +E0571: include_str!("./error_codes/E0571.md"), +E0572: include_str!("./error_codes/E0572.md"), +E0573: include_str!("./error_codes/E0573.md"), +E0574: include_str!("./error_codes/E0574.md"), +E0575: include_str!("./error_codes/E0575.md"), +E0576: include_str!("./error_codes/E0576.md"), +E0577: include_str!("./error_codes/E0577.md"), +E0578: include_str!("./error_codes/E0578.md"), +E0579: include_str!("./error_codes/E0579.md"), +E0580: include_str!("./error_codes/E0580.md"), +E0581: include_str!("./error_codes/E0581.md"), +E0582: include_str!("./error_codes/E0582.md"), +E0583: include_str!("./error_codes/E0583.md"), +E0584: include_str!("./error_codes/E0584.md"), +E0585: include_str!("./error_codes/E0585.md"), +E0586: include_str!("./error_codes/E0586.md"), +E0587: include_str!("./error_codes/E0587.md"), +E0588: include_str!("./error_codes/E0588.md"), +E0589: include_str!("./error_codes/E0589.md"), +E0590: include_str!("./error_codes/E0590.md"), +E0591: include_str!("./error_codes/E0591.md"), +E0592: include_str!("./error_codes/E0592.md"), +E0593: include_str!("./error_codes/E0593.md"), +E0595: include_str!("./error_codes/E0595.md"), +E0596: include_str!("./error_codes/E0596.md"), +E0597: include_str!("./error_codes/E0597.md"), +E0599: include_str!("./error_codes/E0599.md"), +E0600: include_str!("./error_codes/E0600.md"), +E0601: include_str!("./error_codes/E0601.md"), +E0602: include_str!("./error_codes/E0602.md"), +E0603: include_str!("./error_codes/E0603.md"), +E0604: include_str!("./error_codes/E0604.md"), +E0605: include_str!("./error_codes/E0605.md"), +E0606: include_str!("./error_codes/E0606.md"), +E0607: include_str!("./error_codes/E0607.md"), +E0608: include_str!("./error_codes/E0608.md"), +E0609: include_str!("./error_codes/E0609.md"), +E0610: include_str!("./error_codes/E0610.md"), +E0614: include_str!("./error_codes/E0614.md"), +E0615: include_str!("./error_codes/E0615.md"), +E0616: include_str!("./error_codes/E0616.md"), +E0617: include_str!("./error_codes/E0617.md"), +E0618: include_str!("./error_codes/E0618.md"), +E0619: include_str!("./error_codes/E0619.md"), +E0620: include_str!("./error_codes/E0620.md"), +E0621: include_str!("./error_codes/E0621.md"), +E0622: include_str!("./error_codes/E0622.md"), +E0623: include_str!("./error_codes/E0623.md"), +E0624: include_str!("./error_codes/E0624.md"), +E0626: include_str!("./error_codes/E0626.md"), +E0633: include_str!("./error_codes/E0633.md"), +E0635: include_str!("./error_codes/E0635.md"), +E0636: include_str!("./error_codes/E0636.md"), +E0638: include_str!("./error_codes/E0638.md"), +E0639: include_str!("./error_codes/E0639.md"), +E0642: include_str!("./error_codes/E0642.md"), +E0643: include_str!("./error_codes/E0643.md"), +E0644: include_str!("./error_codes/E0644.md"), +E0646: include_str!("./error_codes/E0646.md"), +E0647: include_str!("./error_codes/E0647.md"), +E0648: include_str!("./error_codes/E0648.md"), +E0658: include_str!("./error_codes/E0658.md"), +E0659: include_str!("./error_codes/E0659.md"), +E0660: include_str!("./error_codes/E0660.md"), +E0661: include_str!("./error_codes/E0661.md"), +E0662: include_str!("./error_codes/E0662.md"), +E0663: include_str!("./error_codes/E0663.md"), +E0664: include_str!("./error_codes/E0664.md"), +E0665: include_str!("./error_codes/E0665.md"), +E0666: include_str!("./error_codes/E0666.md"), +E0668: include_str!("./error_codes/E0668.md"), +E0669: include_str!("./error_codes/E0669.md"), +E0670: include_str!("./error_codes/E0670.md"), +E0671: include_str!("./error_codes/E0671.md"), +E0689: include_str!("./error_codes/E0689.md"), +E0690: include_str!("./error_codes/E0690.md"), +E0691: include_str!("./error_codes/E0691.md"), +E0692: include_str!("./error_codes/E0692.md"), +E0695: include_str!("./error_codes/E0695.md"), +E0697: include_str!("./error_codes/E0697.md"), +E0698: include_str!("./error_codes/E0698.md"), +E0699: include_str!("./error_codes/E0699.md"), +E0700: include_str!("./error_codes/E0700.md"), +E0701: include_str!("./error_codes/E0701.md"), +E0704: include_str!("./error_codes/E0704.md"), +E0705: include_str!("./error_codes/E0705.md"), +E0712: include_str!("./error_codes/E0712.md"), +E0713: include_str!("./error_codes/E0713.md"), +E0714: include_str!("./error_codes/E0714.md"), +E0715: include_str!("./error_codes/E0715.md"), +E0716: include_str!("./error_codes/E0716.md"), +E0718: include_str!("./error_codes/E0718.md"), +E0720: include_str!("./error_codes/E0720.md"), +E0723: include_str!("./error_codes/E0723.md"), +E0725: include_str!("./error_codes/E0725.md"), +E0728: include_str!("./error_codes/E0728.md"), +E0729: include_str!("./error_codes/E0729.md"), +E0730: include_str!("./error_codes/E0730.md"), +E0731: include_str!("./error_codes/E0731.md"), +E0732: include_str!("./error_codes/E0732.md"), +E0733: include_str!("./error_codes/E0733.md"), +E0734: include_str!("./error_codes/E0734.md"), +E0735: include_str!("./error_codes/E0735.md"), +E0736: include_str!("./error_codes/E0736.md"), +E0737: include_str!("./error_codes/E0737.md"), +E0738: include_str!("./error_codes/E0738.md"), +E0740: include_str!("./error_codes/E0740.md"), +E0741: include_str!("./error_codes/E0741.md"), +E0742: include_str!("./error_codes/E0742.md"), +E0743: include_str!("./error_codes/E0743.md"), +E0744: include_str!("./error_codes/E0744.md"), +; +// E0006, // merged with E0005 +// E0008, // cannot bind by-move into a pattern guard +// E0035, merged into E0087/E0089 +// E0036, merged into E0087/E0089 +// E0068, +// E0085, +// E0086, +// E0101, // replaced with E0282 +// E0102, // replaced with E0282 +// E0103, +// E0104, +// E0122, // bounds in type aliases are ignored, turned into proper lint +// E0123, +// E0127, +// E0129, +// E0134, +// E0135, +// E0141, +// E0153, unused error code +// E0157, unused error code +// E0159, // use of trait `{}` as struct constructor +// E0163, // merged into E0071 +// E0167, +// E0168, +// E0172, // non-trait found in a type sum, moved to resolve +// E0173, // manual implementations of unboxed closure traits are experimental +// E0174, +// E0182, // merged into E0229 + E0183, +// E0187, // cannot infer the kind of the closure +// E0188, // can not cast an immutable reference to a mutable pointer +// E0189, // deprecated: can only cast a boxed pointer to a boxed object +// E0190, // deprecated: can only cast a &-pointer to an &-object +// E0194, // merged into E0403 +// E0196, // cannot determine a type for this closure + E0203, // type parameter has more than one relaxed default bound, + // and only one is supported + E0208, +// E0209, // builtin traits can only be implemented on structs or enums + E0212, // cannot extract an associated type from a higher-ranked trait bound +// E0213, // associated types are not accepted in this context +// E0215, // angle-bracket notation is not stable with `Fn` +// E0216, // parenthetical notation is only stable with `Fn` +// E0217, // ambiguous associated type, defined in multiple supertraits +// E0218, // no associated type defined +// E0219, // associated type defined in higher-ranked supertrait +// E0222, // Error code E0045 (variadic function must have C or cdecl calling + // convention) duplicate + E0224, // at least one non-builtin train is required for an object type + E0226, // only a single explicit lifetime bound is permitted + E0227, // ambiguous lifetime bound, explicit lifetime bound required + E0228, // explicit lifetime bound required +// E0233, +// E0234, +// E0235, // structure constructor specifies a structure of type but +// E0236, // no lang item for range syntax +// E0237, // no lang item for range syntax +// E0238, // parenthesized parameters may only be used with a trait +// E0239, // `next` method of `Iterator` trait has unexpected type +// E0240, +// E0241, +// E0242, +// E0245, // not a trait +// E0246, // invalid recursive type +// E0247, +// E0248, // value used as a type, now reported earlier during resolution + // as E0412 +// E0249, +// E0257, +// E0258, +// E0272, // on_unimplemented #0 +// E0273, // on_unimplemented #1 +// E0274, // on_unimplemented #2 +// E0278, // requirement is not satisfied + E0279, // requirement is not satisfied + E0280, // requirement is not satisfied +// E0285, // overflow evaluation builtin bounds +// E0296, // replaced with a generic attribute input check +// E0298, // cannot compare constants +// E0299, // mismatched types between arms +// E0300, // unexpanded macro +// E0304, // expected signed integer constant +// E0305, // expected constant + E0311, // thing may not live long enough + E0313, // lifetime of borrowed pointer outlives lifetime of captured + // variable + E0314, // closure outlives stack frame + E0315, // cannot invoke closure outside of its lifetime + E0316, // nested quantification of lifetimes +// E0319, // trait impls for defaulted traits allowed just for structs/enums + E0320, // recursive overflow during dropck +// E0372, // coherence not object safe + E0377, // the trait `CoerceUnsized` may only be implemented for a coercion + // between structures with the same definition +// E0385, // {} in an aliasable location +// E0402, // cannot use an outer type parameter in this context +// E0406, merged into 420 +// E0410, merged into 408 +// E0413, merged into 530 +// E0414, merged into 530 +// E0417, merged into 532 +// E0418, merged into 532 +// E0419, merged into 531 +// E0420, merged into 532 +// E0421, merged into 531 +// E0427, merged into 530 + E0456, // plugin `..` is not available for triple `..` + E0457, // plugin `..` only found in rlib format, but must be available... + E0460, // found possibly newer version of crate `..` + E0461, // couldn't find crate `..` with expected target triple .. + E0462, // found staticlib `..` instead of rlib or dylib + E0464, // multiple matching crates for `..` + E0465, // multiple .. candidates for `..` found +// E0467, removed +// E0470, removed +// E0471, // constant evaluation error (in pattern) + E0472, // asm! is unsupported on this target + E0473, // dereference of reference outside its lifetime + E0474, // captured variable `..` does not outlive the enclosing closure + E0475, // index of slice outside its lifetime + E0476, // lifetime of the source pointer does not outlive lifetime bound... + E0477, // the type `..` does not fulfill the required lifetime... + E0479, // the type `..` (provided as the value of a type parameter) is... + E0480, // lifetime of method receiver does not outlive the method call + E0481, // lifetime of function argument does not outlive the function call + E0482, // lifetime of return value does not outlive the function call + E0483, // lifetime of operand does not outlive the operation + E0484, // reference is not valid at the time of borrow + E0485, // automatically reference is not valid at the time of borrow + E0486, // type of expression contains references that are not valid during.. + E0487, // unsafe use of destructor: destructor might be called while... + E0488, // lifetime of variable does not enclose its declaration + E0489, // type/lifetime parameter not in scope here + E0490, // a value of type `..` is borrowed for too long + E0498, // malformed plugin attribute + E0514, // metadata version mismatch + E0519, // local crate and dependency have same (crate-name, disambiguator) + // two dependencies have same (crate-name, disambiguator) but different SVH + E0521, // borrowed data escapes outside of closure + E0523, +// E0526, // shuffle indices are not constant + E0539, // incorrect meta item + E0540, // multiple rustc_deprecated attributes + E0542, // missing 'since' + E0543, // missing 'reason' + E0544, // multiple stability levels + E0545, // incorrect 'issue' + E0546, // missing 'feature' + E0547, // missing 'issue' +// E0548, // replaced with a generic attribute input check + // rustc_deprecated attribute must be paired with either stable or unstable + // attribute + E0549, + E0553, // multiple rustc_const_unstable attributes +// E0555, // replaced with a generic attribute input check +// E0558, // replaced with a generic attribute input check +// E0563, // cannot determine a type for this `impl Trait` removed in 6383de15 +// E0564, // only named lifetimes are allowed in `impl Trait`, + // but `{}` was found in the type `{}` + E0594, // cannot assign to {} +// E0598, // lifetime of {} is too short to guarantee its contents can be... +// E0611, // merged into E0616 +// E0612, // merged into E0609 +// E0613, // Removed (merged with E0609) + E0625, // thread-local statics cannot be accessed at compile-time + E0627, // yield statement outside of generator literal + E0628, // generators cannot have explicit parameters + E0629, // missing 'feature' (rustc_const_unstable) + // rustc_const_unstable attribute must be paired with stable/unstable + // attribute + E0630, + E0631, // type mismatch in closure arguments + E0632, // cannot provide explicit generic arguments when `impl Trait` is + // used in argument position + E0634, // type has conflicting packed representaton hints + E0637, // "'_" is not a valid lifetime bound + E0640, // infer outlives requirements + E0641, // cannot cast to/from a pointer with an unknown kind +// E0645, // trait aliases not finished + E0657, // `impl Trait` can only capture lifetimes bound at the fn level + E0667, // `impl Trait` in projections + E0687, // in-band lifetimes cannot be used in `fn`/`Fn` syntax + E0688, // in-band lifetimes cannot be mixed with explicit lifetime binders + E0693, // incorrect `repr(align)` attribute format +// E0694, // an unknown tool name found in scoped attributes + E0696, // `continue` pointing to a labeled block +// E0702, // replaced with a generic attribute input check + E0703, // invalid ABI + E0706, // `async fn` in trait +// E0707, // multiple elided lifetimes used in arguments of `async fn` + E0708, // `async` non-`move` closures with parameters are not currently + // supported +// E0709, // multiple different lifetimes used in arguments of `async fn` + E0710, // an unknown tool name found in scoped lint + E0711, // a feature has been declared with conflicting stability attributes + E0717, // rustc_promotable without stability attribute + E0719, // duplicate values for associated type binding +// E0721, // `await` keyword + E0722, // Malformed `#[optimize]` attribute + E0724, // `#[ffi_returns_twice]` is only allowed in foreign functions + E0726, // non-explicit (not `'_`) elided lifetime in unsupported position + E0727, // `async` generators are not yet supported + E0739, // invalid track_caller application/syntax +} diff --git a/src/librustc_error_codes/error_codes/E0001.md b/src/librustc_error_codes/error_codes/E0001.md new file mode 100644 index 00000000000..90756780d15 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0001.md @@ -0,0 +1,24 @@ +#### Note: this error code is no longer emitted by the compiler. + +This error suggests that the expression arm corresponding to the noted pattern +will never be reached as for all possible values of the expression being +matched, one of the preceding patterns will match. + +This means that perhaps some of the preceding patterns are too general, this +one is too specific or the ordering is incorrect. + +For example, the following `match` block has too many arms: + +``` +match Some(0) { + Some(bar) => {/* ... */} + x => {/* ... */} // This handles the `None` case + _ => {/* ... */} // All possible cases have already been handled +} +``` + +`match` blocks have their patterns matched in order, so, for example, putting +a wildcard arm above a more specific arm will make the latter arm irrelevant. + +Ensure the ordering of the match arm is correct and remove any superfluous +arms. diff --git a/src/librustc_error_codes/error_codes/E0002.md b/src/librustc_error_codes/error_codes/E0002.md new file mode 100644 index 00000000000..5cb59da10e0 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0002.md @@ -0,0 +1,29 @@ +#### Note: this error code is no longer emitted by the compiler. + +This error indicates that an empty match expression is invalid because the type +it is matching on is non-empty (there exist values of this type). In safe code +it is impossible to create an instance of an empty type, so empty match +expressions are almost never desired. This error is typically fixed by adding +one or more cases to the match expression. + +An example of an empty type is `enum Empty { }`. So, the following will work: + +``` +enum Empty {} + +fn foo(x: Empty) { + match x { + // empty + } +} +``` + +However, this won't: + +```compile_fail +fn foo(x: Option<String>) { + match x { + // empty + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0004.md b/src/librustc_error_codes/error_codes/E0004.md new file mode 100644 index 00000000000..b79ef5fd8cb --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0004.md @@ -0,0 +1,46 @@ +This error indicates that the compiler cannot guarantee a matching pattern for +one or more possible inputs to a match expression. Guaranteed matches are +required in order to assign values to match expressions, or alternatively, +determine the flow of execution. + +Erroneous code example: + +```compile_fail,E0004 +enum Terminator { + HastaLaVistaBaby, + TalkToMyHand, +} + +let x = Terminator::HastaLaVistaBaby; + +match x { // error: non-exhaustive patterns: `HastaLaVistaBaby` not covered + Terminator::TalkToMyHand => {} +} +``` + +If you encounter this error you must alter your patterns so that every possible +value of the input type is matched. For types with a small number of variants +(like enums) you should probably cover all cases explicitly. Alternatively, the +underscore `_` wildcard pattern can be added after all other patterns to match +"anything else". Example: + +``` +enum Terminator { + HastaLaVistaBaby, + TalkToMyHand, +} + +let x = Terminator::HastaLaVistaBaby; + +match x { + Terminator::TalkToMyHand => {} + Terminator::HastaLaVistaBaby => {} +} + +// or: + +match x { + Terminator::TalkToMyHand => {} + _ => {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0005.md b/src/librustc_error_codes/error_codes/E0005.md new file mode 100644 index 00000000000..e2e7db5082d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0005.md @@ -0,0 +1,30 @@ +Patterns used to bind names must be irrefutable, that is, they must guarantee +that a name will be extracted in all cases. + +Erroneous code example: + +```compile_fail,E0005 +let x = Some(1); +let Some(y) = x; +// error: refutable pattern in local binding: `None` not covered +``` + +If you encounter this error you probably need to use a `match` or `if let` to +deal with the possibility of failure. Example: + +``` +let x = Some(1); + +match x { + Some(y) => { + // do something + }, + None => {} +} + +// or: + +if let Some(y) = x { + // do something +} +``` diff --git a/src/librustc_error_codes/error_codes/E0007.md b/src/librustc_error_codes/error_codes/E0007.md new file mode 100644 index 00000000000..2be7870d5ae --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0007.md @@ -0,0 +1,18 @@ +This error indicates that the bindings in a match arm would require a value to +be moved into more than one location, thus violating unique ownership. Code +like the following is invalid as it requires the entire `Option<String>` to be +moved into a variable called `op_string` while simultaneously requiring the +inner `String` to be moved into a variable called `s`. + +Erroneous code example: + +```compile_fail,E0007 +let x = Some("s".to_string()); + +match x { + op_string @ Some(s) => {}, // error: cannot bind by-move with sub-bindings + None => {}, +} +``` + +See also the error E0303. diff --git a/src/librustc_error_codes/error_codes/E0009.md b/src/librustc_error_codes/error_codes/E0009.md new file mode 100644 index 00000000000..abb7fe41ab7 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0009.md @@ -0,0 +1,48 @@ +In a pattern, all values that don't implement the `Copy` trait have to be bound +the same way. The goal here is to avoid binding simultaneously by-move and +by-ref. + +This limitation may be removed in a future version of Rust. + +Erroneous code example: + +```compile_fail,E0009 +struct X { x: (), } + +let x = Some((X { x: () }, X { x: () })); +match x { + Some((y, ref z)) => {}, // error: cannot bind by-move and by-ref in the + // same pattern + None => panic!() +} +``` + +You have two solutions: + +Solution #1: Bind the pattern's values the same way. + +``` +struct X { x: (), } + +let x = Some((X { x: () }, X { x: () })); +match x { + Some((ref y, ref z)) => {}, + // or Some((y, z)) => {} + None => panic!() +} +``` + +Solution #2: Implement the `Copy` trait for the `X` structure. + +However, please keep in mind that the first solution should be preferred. + +``` +#[derive(Clone, Copy)] +struct X { x: (), } + +let x = Some((X { x: () }, X { x: () })); +match x { + Some((y, ref z)) => {}, + None => panic!() +} +``` diff --git a/src/librustc_error_codes/error_codes/E0010.md b/src/librustc_error_codes/error_codes/E0010.md new file mode 100644 index 00000000000..71c790e102f --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0010.md @@ -0,0 +1,11 @@ +The value of statics and constants must be known at compile time, and they live +for the entire lifetime of a program. Creating a boxed value allocates memory on +the heap at runtime, and therefore cannot be done at compile time. + +Erroneous code example: + +```compile_fail,E0010 +#![feature(box_syntax)] + +const CON : Box<i32> = box 0; +``` diff --git a/src/librustc_error_codes/error_codes/E0013.md b/src/librustc_error_codes/error_codes/E0013.md new file mode 100644 index 00000000000..8de177590ec --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0013.md @@ -0,0 +1,18 @@ +Static and const variables can refer to other const variables. But a const +variable cannot refer to a static variable. + +Erroneous code example: + +```compile_fail,E0013 +static X: i32 = 42; +const Y: i32 = X; +``` + +In this example, `Y` cannot refer to `X` here. To fix this, the value can be +extracted as a const and then used: + +``` +const A: i32 = 42; +static X: i32 = A; +const Y: i32 = A; +``` diff --git a/src/librustc_error_codes/error_codes/E0014.md b/src/librustc_error_codes/error_codes/E0014.md new file mode 100644 index 00000000000..2c69957e9f6 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0014.md @@ -0,0 +1,20 @@ +#### Note: this error code is no longer emitted by the compiler. + +Constants can only be initialized by a constant value or, in a future +version of Rust, a call to a const function. This error indicates the use +of a path (like a::b, or x) denoting something other than one of these +allowed items. + +Erroneous code example: + +``` +const FOO: i32 = { let x = 0; x }; // 'x' isn't a constant nor a function! +``` + +To avoid it, you have to replace the non-constant value: + +``` +const FOO: i32 = { const X : i32 = 0; X }; +// or even: +const FOO2: i32 = { 0 }; // but brackets are useless here +``` diff --git a/src/librustc_error_codes/error_codes/E0015.md b/src/librustc_error_codes/error_codes/E0015.md new file mode 100644 index 00000000000..2bf59983fa9 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0015.md @@ -0,0 +1,14 @@ +The only functions that can be called in static or constant expressions are +`const` functions, and struct/enum constructors. `const` functions are only +available on a nightly compiler. Rust currently does not support more general +compile-time function execution. + +``` +const FOO: Option<u8> = Some(1); // enum constructor +struct Bar {x: u8} +const BAR: Bar = Bar {x: 1}; // struct constructor +``` + +See [RFC 911] for more details on the design of `const fn`s. + +[RFC 911]: https://github.com/rust-lang/rfcs/blob/master/text/0911-const-fn.md diff --git a/src/librustc_error_codes/error_codes/E0017.md b/src/librustc_error_codes/error_codes/E0017.md new file mode 100644 index 00000000000..d5e6857b4d6 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0017.md @@ -0,0 +1,20 @@ +References in statics and constants may only refer to immutable values. + +Erroneous code example: + +```compile_fail,E0017 +static X: i32 = 1; +const C: i32 = 2; + +// these three are not allowed: +const CR: &mut i32 = &mut C; +static STATIC_REF: &'static mut i32 = &mut X; +static CONST_REF: &'static mut i32 = &mut C; +``` + +Statics are shared everywhere, and if they refer to mutable data one might +violate memory safety since holding multiple mutable references to shared data +is not allowed. + +If you really want global mutable state, try using `static mut` or a global +`UnsafeCell`. diff --git a/src/librustc_error_codes/error_codes/E0019.md b/src/librustc_error_codes/error_codes/E0019.md new file mode 100644 index 00000000000..7832468a539 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0019.md @@ -0,0 +1,36 @@ +A function call isn't allowed in the const's initialization expression +because the expression's value must be known at compile-time. + +Erroneous code example: + +```compile_fail,E0019 +#![feature(box_syntax)] + +fn main() { + struct MyOwned; + + static STATIC11: Box<MyOwned> = box MyOwned; // error! +} +``` + +Remember: you can't use a function call inside a const's initialization +expression! However, you can totally use it anywhere else: + +``` +enum Test { + V1 +} + +impl Test { + fn func(&self) -> i32 { + 12 + } +} + +fn main() { + const FOO: Test = Test::V1; + + FOO.func(); // here is good + let x = FOO.func(); // or even here! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0023.md b/src/librustc_error_codes/error_codes/E0023.md new file mode 100644 index 00000000000..92cae460c81 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0023.md @@ -0,0 +1,47 @@ +A pattern used to match against an enum variant must provide a sub-pattern for +each field of the enum variant. This error indicates that a pattern attempted to +extract an incorrect number of fields from a variant. + +``` +enum Fruit { + Apple(String, String), + Pear(u32), +} +``` + +Here the `Apple` variant has two fields, and should be matched against like so: + +``` +enum Fruit { + Apple(String, String), + Pear(u32), +} + +let x = Fruit::Apple(String::new(), String::new()); + +// Correct. +match x { + Fruit::Apple(a, b) => {}, + _ => {} +} +``` + +Matching with the wrong number of fields has no sensible interpretation: + +```compile_fail,E0023 +enum Fruit { + Apple(String, String), + Pear(u32), +} + +let x = Fruit::Apple(String::new(), String::new()); + +// Incorrect. +match x { + Fruit::Apple(a) => {}, + Fruit::Apple(a, b, c) => {}, +} +``` + +Check how many fields the enum was declared with and ensure that your pattern +uses the same number. diff --git a/src/librustc_error_codes/error_codes/E0025.md b/src/librustc_error_codes/error_codes/E0025.md new file mode 100644 index 00000000000..51073babd01 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0025.md @@ -0,0 +1,33 @@ +Each field of a struct can only be bound once in a pattern. Erroneous code +example: + +```compile_fail,E0025 +struct Foo { + a: u8, + b: u8, +} + +fn main(){ + let x = Foo { a:1, b:2 }; + + let Foo { a: x, a: y } = x; + // error: field `a` bound multiple times in the pattern +} +``` + +Each occurrence of a field name binds the value of that field, so to fix this +error you will have to remove or alter the duplicate uses of the field name. +Perhaps you misspelled another field name? Example: + +``` +struct Foo { + a: u8, + b: u8, +} + +fn main(){ + let x = Foo { a:1, b:2 }; + + let Foo { a: x, b: y } = x; // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0026.md b/src/librustc_error_codes/error_codes/E0026.md new file mode 100644 index 00000000000..9327b31ac4b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0026.md @@ -0,0 +1,51 @@ +This error indicates that a struct pattern attempted to extract a non-existent +field from a struct. Struct fields are identified by the name used before the +colon `:` so struct patterns should resemble the declaration of the struct type +being matched. + +``` +// Correct matching. +struct Thing { + x: u32, + y: u32 +} + +let thing = Thing { x: 1, y: 2 }; + +match thing { + Thing { x: xfield, y: yfield } => {} +} +``` + +If you are using shorthand field patterns but want to refer to the struct field +by a different name, you should rename it explicitly. + +Change this: + +```compile_fail,E0026 +struct Thing { + x: u32, + y: u32 +} + +let thing = Thing { x: 0, y: 0 }; + +match thing { + Thing { x, z } => {} +} +``` + +To this: + +``` +struct Thing { + x: u32, + y: u32 +} + +let thing = Thing { x: 0, y: 0 }; + +match thing { + Thing { x, y: z } => {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0027.md b/src/librustc_error_codes/error_codes/E0027.md new file mode 100644 index 00000000000..ab2a20fe9e5 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0027.md @@ -0,0 +1,39 @@ +This error indicates that a pattern for a struct fails to specify a sub-pattern +for every one of the struct's fields. Ensure that each field from the struct's +definition is mentioned in the pattern, or use `..` to ignore unwanted fields. + +For example: + +```compile_fail,E0027 +struct Dog { + name: String, + age: u32, +} + +let d = Dog { name: "Rusty".to_string(), age: 8 }; + +// This is incorrect. +match d { + Dog { age: x } => {} +} +``` + +This is correct (explicit): + +``` +struct Dog { + name: String, + age: u32, +} + +let d = Dog { name: "Rusty".to_string(), age: 8 }; + +match d { + Dog { name: ref n, age: x } => {} +} + +// This is also correct (ignore unused fields). +match d { + Dog { age: x, .. } => {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0029.md b/src/librustc_error_codes/error_codes/E0029.md new file mode 100644 index 00000000000..fadfda0a80c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0029.md @@ -0,0 +1,22 @@ +In a match expression, only numbers and characters can be matched against a +range. This is because the compiler checks that the range is non-empty at +compile-time, and is unable to evaluate arbitrary comparison functions. If you +want to capture values of an orderable type between two end-points, you can use +a guard. + +```compile_fail,E0029 +let string = "salutations !"; + +// The ordering relation for strings cannot be evaluated at compile time, +// so this doesn't work: +match string { + "hello" ..= "world" => {} + _ => {} +} + +// This is a more general version, using a guard: +match string { + s if s >= "hello" && s <= "world" => {} + _ => {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0030.md b/src/librustc_error_codes/error_codes/E0030.md new file mode 100644 index 00000000000..67d496da5e4 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0030.md @@ -0,0 +1,15 @@ +When matching against a range, the compiler verifies that the range is +non-empty. Range patterns include both end-points, so this is equivalent to +requiring the start of the range to be less than or equal to the end of the +range. + +Erroneous code example: + +```compile_fail,E0030 +match 5u32 { + // This range is ok, albeit pointless. + 1 ..= 1 => {} + // This range is empty, and the compiler can tell. + 1000 ..= 5 => {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0033.md b/src/librustc_error_codes/error_codes/E0033.md new file mode 100644 index 00000000000..0bb70e89f3d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0033.md @@ -0,0 +1,23 @@ +This error indicates that a pointer to a trait type cannot be implicitly +dereferenced by a pattern. Every trait defines a type, but because the +size of trait implementers isn't fixed, this type has no compile-time size. +Therefore, all accesses to trait types must be through pointers. If you +encounter this error you should try to avoid dereferencing the pointer. + +```compile_fail,E0033 +# trait SomeTrait { fn method_one(&self){} fn method_two(&self){} } +# impl<T> SomeTrait for T {} +let trait_obj: &SomeTrait = &"some_value"; + +// This tries to implicitly dereference to create an unsized local variable. +let &invalid = trait_obj; + +// You can call methods without binding to the value being pointed at. +trait_obj.method_one(); +trait_obj.method_two(); +``` + +You can read more about trait objects in the [Trait Objects] section of the +Reference. + +[Trait Objects]: https://doc.rust-lang.org/reference/types.html#trait-objects diff --git a/src/librustc_error_codes/error_codes/E0034.md b/src/librustc_error_codes/error_codes/E0034.md new file mode 100644 index 00000000000..bc804b7faef --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0034.md @@ -0,0 +1,84 @@ +The compiler doesn't know what method to call because more than one method +has the same prototype. Erroneous code example: + +```compile_fail,E0034 +struct Test; + +trait Trait1 { + fn foo(); +} + +trait Trait2 { + fn foo(); +} + +impl Trait1 for Test { fn foo() {} } +impl Trait2 for Test { fn foo() {} } + +fn main() { + Test::foo() // error, which foo() to call? +} +``` + +To avoid this error, you have to keep only one of them and remove the others. +So let's take our example and fix it: + +``` +struct Test; + +trait Trait1 { + fn foo(); +} + +impl Trait1 for Test { fn foo() {} } + +fn main() { + Test::foo() // and now that's good! +} +``` + +However, a better solution would be using fully explicit naming of type and +trait: + +``` +struct Test; + +trait Trait1 { + fn foo(); +} + +trait Trait2 { + fn foo(); +} + +impl Trait1 for Test { fn foo() {} } +impl Trait2 for Test { fn foo() {} } + +fn main() { + <Test as Trait1>::foo() +} +``` + +One last example: + +``` +trait F { + fn m(&self); +} + +trait G { + fn m(&self); +} + +struct X; + +impl F for X { fn m(&self) { println!("I am F"); } } +impl G for X { fn m(&self) { println!("I am G"); } } + +fn main() { + let f = X; + + F::m(&f); // it displays "I am F" + G::m(&f); // it displays "I am G" +} +``` diff --git a/src/librustc_error_codes/error_codes/E0038.md b/src/librustc_error_codes/error_codes/E0038.md new file mode 100644 index 00000000000..21b5eb47480 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0038.md @@ -0,0 +1,291 @@ +Trait objects like `Box<Trait>` can only be constructed when certain +requirements are satisfied by the trait in question. + +Trait objects are a form of dynamic dispatch and use a dynamically sized type +for the inner type. So, for a given trait `Trait`, when `Trait` is treated as a +type, as in `Box<Trait>`, the inner type is 'unsized'. In such cases the boxed +pointer is a 'fat pointer' that contains an extra pointer to a table of methods +(among other things) for dynamic dispatch. This design mandates some +restrictions on the types of traits that are allowed to be used in trait +objects, which are collectively termed as 'object safety' rules. + +Attempting to create a trait object for a non object-safe trait will trigger +this error. + +There are various rules: + +### The trait cannot require `Self: Sized` + +When `Trait` is treated as a type, the type does not implement the special +`Sized` trait, because the type does not have a known size at compile time and +can only be accessed behind a pointer. Thus, if we have a trait like the +following: + +``` +trait Foo where Self: Sized { + +} +``` + +We cannot create an object of type `Box<Foo>` or `&Foo` since in this case +`Self` would not be `Sized`. + +Generally, `Self: Sized` is used to indicate that the trait should not be used +as a trait object. If the trait comes from your own crate, consider removing +this restriction. + +### Method references the `Self` type in its parameters or return type + +This happens when a trait has a method like the following: + +``` +trait Trait { + fn foo(&self) -> Self; +} + +impl Trait for String { + fn foo(&self) -> Self { + "hi".to_owned() + } +} + +impl Trait for u8 { + fn foo(&self) -> Self { + 1 + } +} +``` + +(Note that `&self` and `&mut self` are okay, it's additional `Self` types which +cause this problem.) + +In such a case, the compiler cannot predict the return type of `foo()` in a +situation like the following: + +```compile_fail +trait Trait { + fn foo(&self) -> Self; +} + +fn call_foo(x: Box<Trait>) { + let y = x.foo(); // What type is y? + // ... +} +``` + +If only some methods aren't object-safe, you can add a `where Self: Sized` bound +on them to mark them as explicitly unavailable to trait objects. The +functionality will still be available to all other implementers, including +`Box<Trait>` which is itself sized (assuming you `impl Trait for Box<Trait>`). + +``` +trait Trait { + fn foo(&self) -> Self where Self: Sized; + // more functions +} +``` + +Now, `foo()` can no longer be called on a trait object, but you will now be +allowed to make a trait object, and that will be able to call any object-safe +methods. With such a bound, one can still call `foo()` on types implementing +that trait that aren't behind trait objects. + +### Method has generic type parameters + +As mentioned before, trait objects contain pointers to method tables. So, if we +have: + +``` +trait Trait { + fn foo(&self); +} + +impl Trait for String { + fn foo(&self) { + // implementation 1 + } +} + +impl Trait for u8 { + fn foo(&self) { + // implementation 2 + } +} +// ... +``` + +At compile time each implementation of `Trait` will produce a table containing +the various methods (and other items) related to the implementation. + +This works fine, but when the method gains generic parameters, we can have a +problem. + +Usually, generic parameters get _monomorphized_. For example, if I have + +``` +fn foo<T>(x: T) { + // ... +} +``` + +The machine code for `foo::<u8>()`, `foo::<bool>()`, `foo::<String>()`, or any +other type substitution is different. Hence the compiler generates the +implementation on-demand. If you call `foo()` with a `bool` parameter, the +compiler will only generate code for `foo::<bool>()`. When we have additional +type parameters, the number of monomorphized implementations the compiler +generates does not grow drastically, since the compiler will only generate an +implementation if the function is called with unparametrized substitutions +(i.e., substitutions where none of the substituted types are themselves +parametrized). + +However, with trait objects we have to make a table containing _every_ object +that implements the trait. Now, if it has type parameters, we need to add +implementations for every type that implements the trait, and there could +theoretically be an infinite number of types. + +For example, with: + +``` +trait Trait { + fn foo<T>(&self, on: T); + // more methods +} + +impl Trait for String { + fn foo<T>(&self, on: T) { + // implementation 1 + } +} + +impl Trait for u8 { + fn foo<T>(&self, on: T) { + // implementation 2 + } +} + +// 8 more implementations +``` + +Now, if we have the following code: + +```compile_fail,E0038 +# trait Trait { fn foo<T>(&self, on: T); } +# impl Trait for String { fn foo<T>(&self, on: T) {} } +# impl Trait for u8 { fn foo<T>(&self, on: T) {} } +# impl Trait for bool { fn foo<T>(&self, on: T) {} } +# // etc. +fn call_foo(thing: Box<Trait>) { + thing.foo(true); // this could be any one of the 8 types above + thing.foo(1); + thing.foo("hello"); +} +``` + +We don't just need to create a table of all implementations of all methods of +`Trait`, we need to create such a table, for each different type fed to +`foo()`. In this case this turns out to be (10 types implementing `Trait`)*(3 +types being fed to `foo()`) = 30 implementations! + +With real world traits these numbers can grow drastically. + +To fix this, it is suggested to use a `where Self: Sized` bound similar to the +fix for the sub-error above if you do not intend to call the method with type +parameters: + +``` +trait Trait { + fn foo<T>(&self, on: T) where Self: Sized; + // more methods +} +``` + +If this is not an option, consider replacing the type parameter with another +trait object (e.g., if `T: OtherTrait`, use `on: Box<OtherTrait>`). If the +number of types you intend to feed to this method is limited, consider manually +listing out the methods of different types. + +### Method has no receiver + +Methods that do not take a `self` parameter can't be called since there won't be +a way to get a pointer to the method table for them. + +``` +trait Foo { + fn foo() -> u8; +} +``` + +This could be called as `<Foo as Foo>::foo()`, which would not be able to pick +an implementation. + +Adding a `Self: Sized` bound to these methods will generally make this compile. + +``` +trait Foo { + fn foo() -> u8 where Self: Sized; +} +``` + +### The trait cannot contain associated constants + +Just like static functions, associated constants aren't stored on the method +table. If the trait or any subtrait contain an associated constant, they cannot +be made into an object. + +```compile_fail,E0038 +trait Foo { + const X: i32; +} + +impl Foo {} +``` + +A simple workaround is to use a helper method instead: + +``` +trait Foo { + fn x(&self) -> i32; +} +``` + +### The trait cannot use `Self` as a type parameter in the supertrait listing + +This is similar to the second sub-error, but subtler. It happens in situations +like the following: + +```compile_fail,E0038 +trait Super<A: ?Sized> {} + +trait Trait: Super<Self> { +} + +struct Foo; + +impl Super<Foo> for Foo{} + +impl Trait for Foo {} + +fn main() { + let x: Box<dyn Trait>; +} +``` + +Here, the supertrait might have methods as follows: + +``` +trait Super<A: ?Sized> { + fn get_a(&self) -> &A; // note that this is object safe! +} +``` + +If the trait `Trait` was deriving from something like `Super<String>` or +`Super<T>` (where `Foo` itself is `Foo<T>`), this is okay, because given a type +`get_a()` will definitely return an object of that type. + +However, if it derives from `Super<Self>`, even though `Super` is object safe, +the method `get_a()` would return an object of unknown type when called on the +function. `Self` type parameters let us make object safe traits no longer safe, +so they are forbidden when specifying supertraits. + +There's no easy fix for this, generally code will need to be refactored so that +you no longer need to derive from `Super<Self>`. diff --git a/src/librustc_error_codes/error_codes/E0040.md b/src/librustc_error_codes/error_codes/E0040.md new file mode 100644 index 00000000000..fb262018c35 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0040.md @@ -0,0 +1,22 @@ +It is not allowed to manually call destructors in Rust. It is also not +necessary to do this since `drop` is called automatically whenever a value goes +out of scope. + +Here's an example of this error: + +```compile_fail,E0040 +struct Foo { + x: i32, +} + +impl Drop for Foo { + fn drop(&mut self) { + println!("kaboom"); + } +} + +fn main() { + let mut x = Foo { x: -7 }; + x.drop(); // error: explicit use of destructor method +} +``` diff --git a/src/librustc_error_codes/error_codes/E0044.md b/src/librustc_error_codes/error_codes/E0044.md new file mode 100644 index 00000000000..8e877e71859 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0044.md @@ -0,0 +1,14 @@ +You cannot use type or const parameters on foreign items. +Example of erroneous code: + +```compile_fail,E0044 +extern { fn some_func<T>(x: T); } +``` + +To fix this, replace the generic parameter with the specializations that you +need: + +``` +extern { fn some_func_i32(x: i32); } +extern { fn some_func_i64(x: i64); } +``` diff --git a/src/librustc_error_codes/error_codes/E0045.md b/src/librustc_error_codes/error_codes/E0045.md new file mode 100644 index 00000000000..537490eb4cf --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0045.md @@ -0,0 +1,21 @@ +Rust only supports variadic parameters for interoperability with C code in its +FFI. As such, variadic parameters can only be used with functions which are +using the C ABI. Examples of erroneous code: + +```compile_fail +#![feature(unboxed_closures)] + +extern "rust-call" { fn foo(x: u8, ...); } + +// or + +fn foo(x: u8, ...) {} +``` + +To fix such code, put them in an extern "C" block: + +``` +extern "C" { + fn foo (x: u8, ...); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0046.md b/src/librustc_error_codes/error_codes/E0046.md new file mode 100644 index 00000000000..2d0bb0863e8 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0046.md @@ -0,0 +1,29 @@ +Items are missing in a trait implementation. Erroneous code example: + +```compile_fail,E0046 +trait Foo { + fn foo(); +} + +struct Bar; + +impl Foo for Bar {} +// error: not all trait items implemented, missing: `foo` +``` + +When trying to make some type implement a trait `Foo`, you must, at minimum, +provide implementations for all of `Foo`'s required methods (meaning the +methods that do not have default implementations), as well as any required +trait items like associated types or constants. Example: + +``` +trait Foo { + fn foo(); +} + +struct Bar; + +impl Foo for Bar { + fn foo() {} // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0049.md b/src/librustc_error_codes/error_codes/E0049.md new file mode 100644 index 00000000000..721a7fd57a5 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0049.md @@ -0,0 +1,19 @@ +This error indicates that an attempted implementation of a trait method +has the wrong number of type or const parameters. + +For example, the trait below has a method `foo` with a type parameter `T`, +but the implementation of `foo` for the type `Bar` is missing this parameter: + +```compile_fail,E0049 +trait Foo { + fn foo<T: Default>(x: T) -> Self; +} + +struct Bar; + +// error: method `foo` has 0 type parameters but its trait declaration has 1 +// type parameter +impl Foo for Bar { + fn foo(x: bool) -> Self { Bar } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0050.md b/src/librustc_error_codes/error_codes/E0050.md new file mode 100644 index 00000000000..79d070802d3 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0050.md @@ -0,0 +1,20 @@ +This error indicates that an attempted implementation of a trait method +has the wrong number of function parameters. + +For example, the trait below has a method `foo` with two function parameters +(`&self` and `u8`), but the implementation of `foo` for the type `Bar` omits +the `u8` parameter: + +```compile_fail,E0050 +trait Foo { + fn foo(&self, x: u8) -> bool; +} + +struct Bar; + +// error: method `foo` has 1 parameter but the declaration in trait `Foo::foo` +// has 2 +impl Foo for Bar { + fn foo(&self) -> bool { true } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0053.md b/src/librustc_error_codes/error_codes/E0053.md new file mode 100644 index 00000000000..822d1f0094d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0053.md @@ -0,0 +1,21 @@ +The parameters of any trait method must match between a trait implementation +and the trait definition. + +Here are a couple examples of this error: + +```compile_fail,E0053 +trait Foo { + fn foo(x: u16); + fn bar(&self); +} + +struct Bar; + +impl Foo for Bar { + // error, expected u16, found i16 + fn foo(x: i16) { } + + // error, types differ in mutability + fn bar(&mut self) { } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0054.md b/src/librustc_error_codes/error_codes/E0054.md new file mode 100644 index 00000000000..af71cb44462 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0054.md @@ -0,0 +1,16 @@ +It is not allowed to cast to a bool. If you are trying to cast a numeric type +to a bool, you can compare it with zero instead: + +```compile_fail,E0054 +let x = 5; + +// Not allowed, won't compile +let x_is_nonzero = x as bool; +``` + +``` +let x = 5; + +// Ok +let x_is_nonzero = x != 0; +``` diff --git a/src/librustc_error_codes/error_codes/E0055.md b/src/librustc_error_codes/error_codes/E0055.md new file mode 100644 index 00000000000..d5b863081a6 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0055.md @@ -0,0 +1,28 @@ +During a method call, a value is automatically dereferenced as many times as +needed to make the value's type match the method's receiver. The catch is that +the compiler will only attempt to dereference a number of times up to the +recursion limit (which can be set via the `recursion_limit` attribute). + +For a somewhat artificial example: + +```compile_fail,E0055 +#![recursion_limit="5"] + +struct Foo; + +impl Foo { + fn foo(&self) {} +} + +fn main() { + let foo = Foo; + let ref_foo = &&&&&Foo; + + // error, reached the recursion limit while auto-dereferencing `&&&&&Foo` + ref_foo.foo(); +} +``` + +One fix may be to increase the recursion limit. Note that it is possible to +create an infinite recursion of dereferencing, in which case the only fix is to +somehow break the recursion. diff --git a/src/librustc_error_codes/error_codes/E0057.md b/src/librustc_error_codes/error_codes/E0057.md new file mode 100644 index 00000000000..e11c07f835a --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0057.md @@ -0,0 +1,20 @@ +When invoking closures or other implementations of the function traits `Fn`, +`FnMut` or `FnOnce` using call notation, the number of parameters passed to the +function must match its definition. + +An example using a closure: + +```compile_fail,E0057 +let f = |x| x * 3; +let a = f(); // invalid, too few parameters +let b = f(4); // this works! +let c = f(2, 3); // invalid, too many parameters +``` + +A generic function must be treated similarly: + +``` +fn foo<F: Fn()>(f: F) { + f(); // this is valid, but f(3) would not work +} +``` diff --git a/src/librustc_error_codes/error_codes/E0059.md b/src/librustc_error_codes/error_codes/E0059.md new file mode 100644 index 00000000000..b22edead25e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0059.md @@ -0,0 +1,25 @@ +The built-in function traits are generic over a tuple of the function arguments. +If one uses angle-bracket notation (`Fn<(T,), Output=U>`) instead of parentheses +(`Fn(T) -> U`) to denote the function trait, the type parameter should be a +tuple. Otherwise function call notation cannot be used and the trait will not be +implemented by closures. + +The most likely source of this error is using angle-bracket notation without +wrapping the function argument type into a tuple, for example: + +```compile_fail,E0059 +#![feature(unboxed_closures)] + +fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) } +``` + +It can be fixed by adjusting the trait bound like this: + +``` +#![feature(unboxed_closures)] + +fn foo<F: Fn<(i32,)>>(f: F) -> F::Output { f(3) } +``` + +Note that `(T,)` always denotes the type of a 1-tuple containing an element of +type `T`. The comma is necessary for syntactic disambiguation. diff --git a/src/librustc_error_codes/error_codes/E0060.md b/src/librustc_error_codes/error_codes/E0060.md new file mode 100644 index 00000000000..7a07b8e7ed6 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0060.md @@ -0,0 +1,36 @@ +External C functions are allowed to be variadic. However, a variadic function +takes a minimum number of arguments. For example, consider C's variadic `printf` +function: + +``` +use std::os::raw::{c_char, c_int}; + +extern "C" { + fn printf(_: *const c_char, ...) -> c_int; +} +``` + +Using this declaration, it must be called with at least one argument, so +simply calling `printf()` is invalid. But the following uses are allowed: + +``` +# #![feature(static_nobundle)] +# use std::os::raw::{c_char, c_int}; +# #[cfg_attr(all(windows, target_env = "msvc"), +# link(name = "legacy_stdio_definitions", kind = "static-nobundle"))] +# extern "C" { fn printf(_: *const c_char, ...) -> c_int; } +# fn main() { +unsafe { + use std::ffi::CString; + + let fmt = CString::new("test\n").unwrap(); + printf(fmt.as_ptr()); + + let fmt = CString::new("number = %d\n").unwrap(); + printf(fmt.as_ptr(), 3); + + let fmt = CString::new("%d, %d\n").unwrap(); + printf(fmt.as_ptr(), 10, 5); +} +# } +``` diff --git a/src/librustc_error_codes/error_codes/E0061.md b/src/librustc_error_codes/error_codes/E0061.md new file mode 100644 index 00000000000..3386dff2c85 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0061.md @@ -0,0 +1,13 @@ +The number of arguments passed to a function must match the number of arguments +specified in the function signature. + +For example, a function like: + +``` +fn f(a: u16, b: &str) {} +``` + +Must always be called with exactly two arguments, e.g., `f(2, "test")`. + +Note that Rust does not have a notion of optional function arguments or +variadic functions (except for its C-FFI). diff --git a/src/librustc_error_codes/error_codes/E0062.md b/src/librustc_error_codes/error_codes/E0062.md new file mode 100644 index 00000000000..0ebeb1bd78e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0062.md @@ -0,0 +1,28 @@ +This error indicates that during an attempt to build a struct or struct-like +enum variant, one of the fields was specified more than once. Erroneous code +example: + +```compile_fail,E0062 +struct Foo { + x: i32, +} + +fn main() { + let x = Foo { + x: 0, + x: 0, // error: field `x` specified more than once + }; +} +``` + +Each field should be specified exactly one time. Example: + +``` +struct Foo { + x: i32, +} + +fn main() { + let x = Foo { x: 0 }; // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0063.md b/src/librustc_error_codes/error_codes/E0063.md new file mode 100644 index 00000000000..0d1f60437ac --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0063.md @@ -0,0 +1,26 @@ +This error indicates that during an attempt to build a struct or struct-like +enum variant, one of the fields was not provided. Erroneous code example: + +```compile_fail,E0063 +struct Foo { + x: i32, + y: i32, +} + +fn main() { + let x = Foo { x: 0 }; // error: missing field: `y` +} +``` + +Each field should be specified exactly once. Example: + +``` +struct Foo { + x: i32, + y: i32, +} + +fn main() { + let x = Foo { x: 0, y: 0 }; // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0067.md b/src/librustc_error_codes/error_codes/E0067.md new file mode 100644 index 00000000000..101b96f7983 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0067.md @@ -0,0 +1,33 @@ +The left-hand side of a compound assignment expression must be a place +expression. A place expression represents a memory location and includes +item paths (ie, namespaced variables), dereferences, indexing expressions, +and field references. + +Let's start with some erroneous code examples: + +```compile_fail,E0067 +use std::collections::LinkedList; + +// Bad: assignment to non-place expression +LinkedList::new() += 1; + +// ... + +fn some_func(i: &mut i32) { + i += 12; // Error : '+=' operation cannot be applied on a reference ! +} +``` + +And now some working examples: + +``` +let mut i : i32 = 0; + +i += 12; // Good ! + +// ... + +fn some_func(i: &mut i32) { + *i += 12; // Good ! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0069.md b/src/librustc_error_codes/error_codes/E0069.md new file mode 100644 index 00000000000..ad3b1803b54 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0069.md @@ -0,0 +1,12 @@ +The compiler found a function whose body contains a `return;` statement but +whose return type is not `()`. An example of this is: + +```compile_fail,E0069 +// error +fn foo() -> u8 { + return; +} +``` + +Since `return;` is just like `return ();`, there is a mismatch between the +function's return type and the value being returned. diff --git a/src/librustc_error_codes/error_codes/E0070.md b/src/librustc_error_codes/error_codes/E0070.md new file mode 100644 index 00000000000..1a56080a097 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0070.md @@ -0,0 +1,47 @@ +The left-hand side of an assignment operator must be a place expression. A +place expression represents a memory location and can be a variable (with +optional namespacing), a dereference, an indexing expression or a field +reference. + +More details can be found in the [Expressions] section of the Reference. + +[Expressions]: https://doc.rust-lang.org/reference/expressions.html#places-rvalues-and-temporaries + +Now, we can go further. Here are some erroneous code examples: + +```compile_fail,E0070 +struct SomeStruct { + x: i32, + y: i32 +} + +const SOME_CONST : i32 = 12; + +fn some_other_func() {} + +fn some_function() { + SOME_CONST = 14; // error : a constant value cannot be changed! + 1 = 3; // error : 1 isn't a valid place! + some_other_func() = 4; // error : we cannot assign value to a function! + SomeStruct.x = 12; // error : SomeStruct a structure name but it is used + // like a variable! +} +``` + +And now let's give working examples: + +``` +struct SomeStruct { + x: i32, + y: i32 +} +let mut s = SomeStruct {x: 0, y: 0}; + +s.x = 3; // that's good ! + +// ... + +fn some_func(x: &mut i32) { + *x = 12; // that's good ! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0071.md b/src/librustc_error_codes/error_codes/E0071.md new file mode 100644 index 00000000000..768dd0c7a48 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0071.md @@ -0,0 +1,27 @@ +You tried to use structure-literal syntax to create an item that is +not a structure or enum variant. + +Example of erroneous code: + +```compile_fail,E0071 +type U32 = u32; +let t = U32 { value: 4 }; // error: expected struct, variant or union type, + // found builtin type `u32` +``` + +To fix this, ensure that the name was correctly spelled, and that +the correct form of initializer was used. + +For example, the code above can be fixed to: + +``` +enum Foo { + FirstValue(i32) +} + +fn main() { + let u = Foo::FirstValue(0i32); + + let t = 4; +} +``` diff --git a/src/librustc_error_codes/error_codes/E0072.md b/src/librustc_error_codes/error_codes/E0072.md new file mode 100644 index 00000000000..e461d45f30c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0072.md @@ -0,0 +1,34 @@ +When defining a recursive struct or enum, any use of the type being defined +from inside the definition must occur behind a pointer (like `Box` or `&`). +This is because structs and enums must have a well-defined size, and without +the pointer, the size of the type would need to be unbounded. + +Consider the following erroneous definition of a type for a list of bytes: + +```compile_fail,E0072 +// error, invalid recursive struct type +struct ListNode { + head: u8, + tail: Option<ListNode>, +} +``` + +This type cannot have a well-defined size, because it needs to be arbitrarily +large (since we would be able to nest `ListNode`s to any depth). Specifically, + +```plain +size of `ListNode` = 1 byte for `head` + + 1 byte for the discriminant of the `Option` + + size of `ListNode` +``` + +One way to fix this is by wrapping `ListNode` in a `Box`, like so: + +``` +struct ListNode { + head: u8, + tail: Option<Box<ListNode>>, +} +``` + +This works because `Box` is a pointer, so its size is well-known. diff --git a/src/librustc_error_codes/error_codes/E0073.md b/src/librustc_error_codes/error_codes/E0073.md new file mode 100644 index 00000000000..a5aea86ff2d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0073.md @@ -0,0 +1,19 @@ +#### Note: this error code is no longer emitted by the compiler. + +You cannot define a struct (or enum) `Foo` that requires an instance of `Foo` +in order to make a new `Foo` value. This is because there would be no way a +first instance of `Foo` could be made to initialize another instance! + +Here's an example of a struct that has this problem: + +``` +struct Foo { x: Box<Foo> } // error +``` + +One fix is to use `Option`, like so: + +``` +struct Foo { x: Option<Box<Foo>> } +``` + +Now it's possible to create at least one instance of `Foo`: `Foo { x: None }`. diff --git a/src/librustc_error_codes/error_codes/E0074.md b/src/librustc_error_codes/error_codes/E0074.md new file mode 100644 index 00000000000..e25dec7681b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0074.md @@ -0,0 +1,24 @@ +#### Note: this error code is no longer emitted by the compiler. + +When using the `#[simd]` attribute on a tuple struct, the components of the +tuple struct must all be of a concrete, nongeneric type so the compiler can +reason about how to use SIMD with them. This error will occur if the types +are generic. + +This will cause an error: + +``` +#![feature(repr_simd)] + +#[repr(simd)] +struct Bad<T>(T, T, T); +``` + +This will not: + +``` +#![feature(repr_simd)] + +#[repr(simd)] +struct Good(u32, u32, u32); +``` diff --git a/src/librustc_error_codes/error_codes/E0075.md b/src/librustc_error_codes/error_codes/E0075.md new file mode 100644 index 00000000000..f15af8150ba --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0075.md @@ -0,0 +1,21 @@ +The `#[simd]` attribute can only be applied to non empty tuple structs, because +it doesn't make sense to try to use SIMD operations when there are no values to +operate on. + +This will cause an error: + +```compile_fail,E0075 +#![feature(repr_simd)] + +#[repr(simd)] +struct Bad; +``` + +This will not: + +``` +#![feature(repr_simd)] + +#[repr(simd)] +struct Good(u32); +``` diff --git a/src/librustc_error_codes/error_codes/E0076.md b/src/librustc_error_codes/error_codes/E0076.md new file mode 100644 index 00000000000..466e0a96e6b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0076.md @@ -0,0 +1,21 @@ +When using the `#[simd]` attribute to automatically use SIMD operations in tuple +struct, the types in the struct must all be of the same type, or the compiler +will trigger this error. + +This will cause an error: + +```compile_fail,E0076 +#![feature(repr_simd)] + +#[repr(simd)] +struct Bad(u16, u32, u32); +``` + +This will not: + +``` +#![feature(repr_simd)] + +#[repr(simd)] +struct Good(u32, u32, u32); +``` diff --git a/src/librustc_error_codes/error_codes/E0077.md b/src/librustc_error_codes/error_codes/E0077.md new file mode 100644 index 00000000000..6ae35a6aa17 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0077.md @@ -0,0 +1,20 @@ +When using the `#[simd]` attribute on a tuple struct, the elements in the tuple +must be machine types so SIMD operations can be applied to them. + +This will cause an error: + +```compile_fail,E0077 +#![feature(repr_simd)] + +#[repr(simd)] +struct Bad(String); +``` + +This will not: + +``` +#![feature(repr_simd)] + +#[repr(simd)] +struct Good(u32, u32, u32); +``` diff --git a/src/librustc_error_codes/error_codes/E0080.md b/src/librustc_error_codes/error_codes/E0080.md new file mode 100644 index 00000000000..262bf00d385 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0080.md @@ -0,0 +1,16 @@ +This error indicates that the compiler was unable to sensibly evaluate a +constant expression that had to be evaluated. Attempting to divide by 0 +or causing integer overflow are two ways to induce this error. For example: + +```compile_fail,E0080 +enum Enum { + X = (1 << 500), + Y = (1 / 0) +} +``` + +Ensure that the expressions given can be evaluated as the desired integer type. +See the FFI section of the Reference for more information about using a custom +integer type: + +https://doc.rust-lang.org/reference.html#ffi-attributes diff --git a/src/librustc_error_codes/error_codes/E0081.md b/src/librustc_error_codes/error_codes/E0081.md new file mode 100644 index 00000000000..ec88ca9765e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0081.md @@ -0,0 +1,35 @@ +Enum discriminants are used to differentiate enum variants stored in memory. +This error indicates that the same value was used for two or more variants, +making them impossible to tell apart. + +```compile_fail,E0081 +// Bad. +enum Enum { + P = 3, + X = 3, + Y = 5, +} +``` + +``` +// Good. +enum Enum { + P, + X = 3, + Y = 5, +} +``` + +Note that variants without a manually specified discriminant are numbered from +top to bottom starting from 0, so clashes can occur with seemingly unrelated +variants. + +```compile_fail,E0081 +enum Bad { + X, + Y = 0 +} +``` + +Here `X` will have already been specified the discriminant 0 by the time `Y` is +encountered, so a conflict occurs. diff --git a/src/librustc_error_codes/error_codes/E0084.md b/src/librustc_error_codes/error_codes/E0084.md new file mode 100644 index 00000000000..2388bc635d9 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0084.md @@ -0,0 +1,27 @@ +An unsupported representation was attempted on a zero-variant enum. + +Erroneous code example: + +```compile_fail,E0084 +#[repr(i32)] +enum NightsWatch {} // error: unsupported representation for zero-variant enum +``` + +It is impossible to define an integer type to be used to represent zero-variant +enum values because there are no zero-variant enum values. There is no way to +construct an instance of the following type using only safe code. So you have +two solutions. Either you add variants in your enum: + +``` +#[repr(i32)] +enum NightsWatch { + JonSnow, + Commander, +} +``` + +or you remove the integer represention of your enum: + +``` +enum NightsWatch {} +``` diff --git a/src/librustc_error_codes/error_codes/E0087.md b/src/librustc_error_codes/error_codes/E0087.md new file mode 100644 index 00000000000..9d292186f0f --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0087.md @@ -0,0 +1,15 @@ +#### Note: this error code is no longer emitted by the compiler. + +Too many type arguments were supplied for a function. For example: + +```compile_fail,E0107 +fn foo<T>() {} + +fn main() { + foo::<f64, bool>(); // error: wrong number of type arguments: + // expected 1, found 2 +} +``` + +The number of supplied arguments must exactly match the number of defined type +parameters. diff --git a/src/librustc_error_codes/error_codes/E0088.md b/src/librustc_error_codes/error_codes/E0088.md new file mode 100644 index 00000000000..7780ad5b56e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0088.md @@ -0,0 +1,45 @@ +#### Note: this error code is no longer emitted by the compiler. + +You gave too many lifetime arguments. Erroneous code example: + +```compile_fail,E0107 +fn f() {} + +fn main() { + f::<'static>() // error: wrong number of lifetime arguments: + // expected 0, found 1 +} +``` + +Please check you give the right number of lifetime arguments. Example: + +``` +fn f() {} + +fn main() { + f() // ok! +} +``` + +It's also important to note that the Rust compiler can generally +determine the lifetime by itself. Example: + +``` +struct Foo { + value: String +} + +impl Foo { + // it can be written like this + fn get_value<'a>(&'a self) -> &'a str { &self.value } + // but the compiler works fine with this too: + fn without_lifetime(&self) -> &str { &self.value } +} + +fn main() { + let f = Foo { value: "hello".to_owned() }; + + println!("{}", f.get_value()); + println!("{}", f.without_lifetime()); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0089.md b/src/librustc_error_codes/error_codes/E0089.md new file mode 100644 index 00000000000..504fbc7b96a --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0089.md @@ -0,0 +1,25 @@ +#### Note: this error code is no longer emitted by the compiler. + +Too few type arguments were supplied for a function. For example: + +```compile_fail,E0107 +fn foo<T, U>() {} + +fn main() { + foo::<f64>(); // error: wrong number of type arguments: expected 2, found 1 +} +``` + +Note that if a function takes multiple type arguments but you want the compiler +to infer some of them, you can use type placeholders: + +```compile_fail,E0107 +fn foo<T, U>(x: T) {} + +fn main() { + let x: bool = true; + foo::<f64>(x); // error: wrong number of type arguments: + // expected 2, found 1 + foo::<_, f64>(x); // same as `foo::<bool, f64>(x)` +} +``` diff --git a/src/librustc_error_codes/error_codes/E0090.md b/src/librustc_error_codes/error_codes/E0090.md new file mode 100644 index 00000000000..e091bb6c9f2 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0090.md @@ -0,0 +1,22 @@ +#### Note: this error code is no longer emitted by the compiler. + +You gave too few lifetime arguments. Example: + +```compile_fail,E0107 +fn foo<'a: 'b, 'b: 'a>() {} + +fn main() { + foo::<'static>(); // error: wrong number of lifetime arguments: + // expected 2, found 1 +} +``` + +Please check you give the right number of lifetime arguments. Example: + +``` +fn foo<'a: 'b, 'b: 'a>() {} + +fn main() { + foo::<'static, 'static>(); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0091.md b/src/librustc_error_codes/error_codes/E0091.md new file mode 100644 index 00000000000..2a092402429 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0091.md @@ -0,0 +1,15 @@ +You gave an unnecessary type or const parameter in a type alias. Erroneous +code example: + +```compile_fail,E0091 +type Foo<T> = u32; // error: type parameter `T` is unused +// or: +type Foo<A,B> = Box<A>; // error: type parameter `B` is unused +``` + +Please check you didn't write too many parameters. Example: + +``` +type Foo = u32; // ok! +type Foo2<A> = Box<A>; // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0092.md b/src/librustc_error_codes/error_codes/E0092.md new file mode 100644 index 00000000000..2750a7d45b4 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0092.md @@ -0,0 +1,23 @@ +You tried to declare an undefined atomic operation function. +Erroneous code example: + +```compile_fail,E0092 +#![feature(intrinsics)] + +extern "rust-intrinsic" { + fn atomic_foo(); // error: unrecognized atomic operation + // function +} +``` + +Please check you didn't make a mistake in the function's name. All intrinsic +functions are defined in librustc_codegen_llvm/intrinsic.rs and in +libcore/intrinsics.rs in the Rust source code. Example: + +``` +#![feature(intrinsics)] + +extern "rust-intrinsic" { + fn atomic_fence(); // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0093.md b/src/librustc_error_codes/error_codes/E0093.md new file mode 100644 index 00000000000..9633f794d8b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0093.md @@ -0,0 +1,33 @@ +You declared an unknown intrinsic function. Erroneous code example: + +```compile_fail,E0093 +#![feature(intrinsics)] + +extern "rust-intrinsic" { + fn foo(); // error: unrecognized intrinsic function: `foo` +} + +fn main() { + unsafe { + foo(); + } +} +``` + +Please check you didn't make a mistake in the function's name. All intrinsic +functions are defined in librustc_codegen_llvm/intrinsic.rs and in +libcore/intrinsics.rs in the Rust source code. Example: + +``` +#![feature(intrinsics)] + +extern "rust-intrinsic" { + fn atomic_fence(); // ok! +} + +fn main() { + unsafe { + atomic_fence(); + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0094.md b/src/librustc_error_codes/error_codes/E0094.md new file mode 100644 index 00000000000..4d27f616d2d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0094.md @@ -0,0 +1,23 @@ +You gave an invalid number of type parameters to an intrinsic function. +Erroneous code example: + +```compile_fail,E0094 +#![feature(intrinsics)] + +extern "rust-intrinsic" { + fn size_of<T, U>() -> usize; // error: intrinsic has wrong number + // of type parameters +} +``` + +Please check that you provided the right number of type parameters +and verify with the function declaration in the Rust source code. +Example: + +``` +#![feature(intrinsics)] + +extern "rust-intrinsic" { + fn size_of<T>() -> usize; // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0106.md b/src/librustc_error_codes/error_codes/E0106.md new file mode 100644 index 00000000000..8a49c1f79e4 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0106.md @@ -0,0 +1,53 @@ +This error indicates that a lifetime is missing from a type. If it is an error +inside a function signature, the problem may be with failing to adhere to the +lifetime elision rules (see below). + +Here are some simple examples of where you'll run into this error: + +```compile_fail,E0106 +struct Foo1 { x: &bool } + // ^ expected lifetime parameter +struct Foo2<'a> { x: &'a bool } // correct + +struct Bar1 { x: Foo2 } + // ^^^^ expected lifetime parameter +struct Bar2<'a> { x: Foo2<'a> } // correct + +enum Baz1 { A(u8), B(&bool), } + // ^ expected lifetime parameter +enum Baz2<'a> { A(u8), B(&'a bool), } // correct + +type MyStr1 = &str; + // ^ expected lifetime parameter +type MyStr2<'a> = &'a str; // correct +``` + +Lifetime elision is a special, limited kind of inference for lifetimes in +function signatures which allows you to leave out lifetimes in certain cases. +For more background on lifetime elision see [the book][book-le]. + +The lifetime elision rules require that any function signature with an elided +output lifetime must either have + + - exactly one input lifetime + - or, multiple input lifetimes, but the function must also be a method with a + `&self` or `&mut self` receiver + +In the first case, the output lifetime is inferred to be the same as the unique +input lifetime. In the second case, the lifetime is instead inferred to be the +same as the lifetime on `&self` or `&mut self`. + +Here are some examples of elision errors: + +```compile_fail,E0106 +// error, no input lifetimes +fn foo() -> &str { } + +// error, `x` and `y` have distinct lifetimes inferred +fn bar(x: &str, y: &str) -> &str { } + +// error, `y`'s lifetime is inferred to be distinct from `x`'s +fn baz<'a>(x: &'a str, y: &str) -> &str { } +``` + +[book-le]: https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html#lifetime-elision diff --git a/src/librustc_error_codes/error_codes/E0107.md b/src/librustc_error_codes/error_codes/E0107.md new file mode 100644 index 00000000000..3a8acba061c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0107.md @@ -0,0 +1,28 @@ +This error means that an incorrect number of generic arguments were provided: + +```compile_fail,E0107 +struct Foo<T> { x: T } + +struct Bar { x: Foo } // error: wrong number of type arguments: + // expected 1, found 0 +struct Baz<S, T> { x: Foo<S, T> } // error: wrong number of type arguments: + // expected 1, found 2 + +fn foo<T, U>(x: T, y: U) {} + +fn main() { + let x: bool = true; + foo::<bool>(x); // error: wrong number of type arguments: + // expected 2, found 1 + foo::<bool, i32, i32>(x, 2, 4); // error: wrong number of type arguments: + // expected 2, found 3 +} + +fn f() {} + +fn main() { + f::<'static>(); // error: wrong number of lifetime arguments: + // expected 0, found 1 +} +``` + diff --git a/src/librustc_error_codes/error_codes/E0109.md b/src/librustc_error_codes/error_codes/E0109.md new file mode 100644 index 00000000000..5bc229ade52 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0109.md @@ -0,0 +1,21 @@ +You tried to provide a generic argument to a type which doesn't need it. +Erroneous code example: + +```compile_fail,E0109 +type X = u32<i32>; // error: type arguments are not allowed for this type +type Y = bool<'static>; // error: lifetime parameters are not allowed on + // this type +``` + +Check that you used the correct argument and that the definition is correct. + +Example: + +``` +type X = u32; // ok! +type Y = bool; // ok! +``` + +Note that generic arguments for enum variant constructors go after the variant, +not after the enum. For example, you would write `Option::None::<u32>`, +rather than `Option::<u32>::None`. diff --git a/src/librustc_error_codes/error_codes/E0110.md b/src/librustc_error_codes/error_codes/E0110.md new file mode 100644 index 00000000000..b9fe406ffb9 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0110.md @@ -0,0 +1,4 @@ +#### Note: this error code is no longer emitted by the compiler. + +You tried to provide a lifetime to a type which doesn't need it. +See `E0109` for more details. diff --git a/src/librustc_error_codes/error_codes/E0116.md b/src/librustc_error_codes/error_codes/E0116.md new file mode 100644 index 00000000000..27759a42343 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0116.md @@ -0,0 +1,23 @@ +You can only define an inherent implementation for a type in the same crate +where the type was defined. For example, an `impl` block as below is not allowed +since `Vec` is defined in the standard library: + +```compile_fail,E0116 +impl Vec<u8> { } // error +``` + +To fix this problem, you can do either of these things: + + - define a trait that has the desired associated functions/types/constants and + implement the trait for the type in question + - define a new type wrapping the type and define an implementation on the new + type + +Note that using the `type` keyword does not work here because `type` only +introduces a type alias: + +```compile_fail,E0116 +type Bytes = Vec<u8>; + +impl Bytes { } // error, same as above +``` diff --git a/src/librustc_error_codes/error_codes/E0117.md b/src/librustc_error_codes/error_codes/E0117.md new file mode 100644 index 00000000000..bd362305662 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0117.md @@ -0,0 +1,48 @@ +This error indicates a violation of one of Rust's orphan rules for trait +implementations. The rule prohibits any implementation of a foreign trait (a +trait defined in another crate) where + + - the type that is implementing the trait is foreign + - all of the parameters being passed to the trait (if there are any) are also + foreign. + +Here's one example of this error: + +```compile_fail,E0117 +impl Drop for u32 {} +``` + +To avoid this kind of error, ensure that at least one local type is referenced +by the `impl`: + +``` +pub struct Foo; // you define your type in your crate + +impl Drop for Foo { // and you can implement the trait on it! + // code of trait implementation here +# fn drop(&mut self) { } +} + +impl From<Foo> for i32 { // or you use a type from your crate as + // a type parameter + fn from(i: Foo) -> i32 { + 0 + } +} +``` + +Alternatively, define a trait locally and implement that instead: + +``` +trait Bar { + fn get(&self) -> usize; +} + +impl Bar for u32 { + fn get(&self) -> usize { 0 } +} +``` + +For information on the design of the orphan rules, see [RFC 1023]. + +[RFC 1023]: https://github.com/rust-lang/rfcs/blob/master/text/1023-rebalancing-coherence.md diff --git a/src/librustc_error_codes/error_codes/E0118.md b/src/librustc_error_codes/error_codes/E0118.md new file mode 100644 index 00000000000..baf35ffbb0b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0118.md @@ -0,0 +1,41 @@ +You're trying to write an inherent implementation for something which isn't a +struct nor an enum. Erroneous code example: + +```compile_fail,E0118 +impl (u8, u8) { // error: no base type found for inherent implementation + fn get_state(&self) -> String { + // ... + } +} +``` + +To fix this error, please implement a trait on the type or wrap it in a struct. +Example: + +``` +// we create a trait here +trait LiveLongAndProsper { + fn get_state(&self) -> String; +} + +// and now you can implement it on (u8, u8) +impl LiveLongAndProsper for (u8, u8) { + fn get_state(&self) -> String { + "He's dead, Jim!".to_owned() + } +} +``` + +Alternatively, you can create a newtype. A newtype is a wrapping tuple-struct. +For example, `NewType` is a newtype over `Foo` in `struct NewType(Foo)`. +Example: + +``` +struct TypeWrapper((u8, u8)); + +impl TypeWrapper { + fn get_state(&self) -> String { + "Fascinating!".to_owned() + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0119.md b/src/librustc_error_codes/error_codes/E0119.md new file mode 100644 index 00000000000..0af3bd4a0de --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0119.md @@ -0,0 +1,58 @@ +There are conflicting trait implementations for the same type. +Example of erroneous code: + +```compile_fail,E0119 +trait MyTrait { + fn get(&self) -> usize; +} + +impl<T> MyTrait for T { + fn get(&self) -> usize { 0 } +} + +struct Foo { + value: usize +} + +impl MyTrait for Foo { // error: conflicting implementations of trait + // `MyTrait` for type `Foo` + fn get(&self) -> usize { self.value } +} +``` + +When looking for the implementation for the trait, the compiler finds +both the `impl<T> MyTrait for T` where T is all types and the `impl +MyTrait for Foo`. Since a trait cannot be implemented multiple times, +this is an error. So, when you write: + +``` +trait MyTrait { + fn get(&self) -> usize; +} + +impl<T> MyTrait for T { + fn get(&self) -> usize { 0 } +} +``` + +This makes the trait implemented on all types in the scope. So if you +try to implement it on another one after that, the implementations will +conflict. Example: + +``` +trait MyTrait { + fn get(&self) -> usize; +} + +impl<T> MyTrait for T { + fn get(&self) -> usize { 0 } +} + +struct Foo; + +fn main() { + let f = Foo; + + f.get(); // the trait is implemented so we can use it +} +``` diff --git a/src/librustc_error_codes/error_codes/E0120.md b/src/librustc_error_codes/error_codes/E0120.md new file mode 100644 index 00000000000..99c2a493a46 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0120.md @@ -0,0 +1,36 @@ +An attempt was made to implement Drop on a trait, which is not allowed: only +structs and enums can implement Drop. An example causing this error: + +```compile_fail,E0120 +trait MyTrait {} + +impl Drop for MyTrait { + fn drop(&mut self) {} +} +``` + +A workaround for this problem is to wrap the trait up in a struct, and implement +Drop on that. An example is shown below: + +``` +trait MyTrait {} +struct MyWrapper<T: MyTrait> { foo: T } + +impl <T: MyTrait> Drop for MyWrapper<T> { + fn drop(&mut self) {} +} + +``` + +Alternatively, wrapping trait objects requires something like the following: + +``` +trait MyTrait {} + +//or Box<MyTrait>, if you wanted an owned trait object +struct MyWrapper<'a> { foo: &'a MyTrait } + +impl <'a> Drop for MyWrapper<'a> { + fn drop(&mut self) {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0121.md b/src/librustc_error_codes/error_codes/E0121.md new file mode 100644 index 00000000000..069d0fc48fb --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0121.md @@ -0,0 +1,10 @@ +In order to be consistent with Rust's lack of global type inference, +type and const placeholders are disallowed by design in item signatures. + +Examples of this error include: + +```compile_fail,E0121 +fn foo() -> _ { 5 } // error, explicitly write out the return type instead + +static BAR: _ = "test"; // error, explicitly write out the type instead +``` diff --git a/src/librustc_error_codes/error_codes/E0124.md b/src/librustc_error_codes/error_codes/E0124.md new file mode 100644 index 00000000000..a7836526a7d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0124.md @@ -0,0 +1,18 @@ +You declared two fields of a struct with the same name. Erroneous code +example: + +```compile_fail,E0124 +struct Foo { + field1: i32, + field1: i32, // error: field is already declared +} +``` + +Please verify that the field names have been correctly spelled. Example: + +``` +struct Foo { + field1: i32, + field2: i32, // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0128.md b/src/librustc_error_codes/error_codes/E0128.md new file mode 100644 index 00000000000..d0a4b32f968 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0128.md @@ -0,0 +1,24 @@ +Type parameter defaults can only use parameters that occur before them. +Erroneous code example: + +```compile_fail,E0128 +struct Foo<T = U, U = ()> { + field1: T, + field2: U, +} +// error: type parameters with a default cannot use forward declared +// identifiers +``` + +Since type parameters are evaluated in-order, you may be able to fix this issue +by doing: + +``` +struct Foo<U = (), T = U> { + field1: T, + field2: U, +} +``` + +Please also verify that this wasn't because of a name-clash and rename the type +parameter if so. diff --git a/src/librustc_error_codes/error_codes/E0130.md b/src/librustc_error_codes/error_codes/E0130.md new file mode 100644 index 00000000000..5273f3ad14f --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0130.md @@ -0,0 +1,31 @@ +You declared a pattern as an argument in a foreign function declaration. + +Erroneous code example: + +```compile_fail +extern { + fn foo((a, b): (u32, u32)); // error: patterns aren't allowed in foreign + // function declarations +} +``` + +Please replace the pattern argument with a regular one. Example: + +``` +struct SomeStruct { + a: u32, + b: u32, +} + +extern { + fn foo(s: SomeStruct); // ok! +} +``` + +Or: + +``` +extern { + fn foo(a: (u32, u32)); // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0131.md b/src/librustc_error_codes/error_codes/E0131.md new file mode 100644 index 00000000000..a70a02925b0 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0131.md @@ -0,0 +1,8 @@ +It is not possible to define `main` with generic parameters. +When `main` is present, it must take no arguments and return `()`. +Erroneous code example: + +```compile_fail,E0131 +fn main<T>() { // error: main function is not allowed to have generic parameters +} +``` diff --git a/src/librustc_error_codes/error_codes/E0132.md b/src/librustc_error_codes/error_codes/E0132.md new file mode 100644 index 00000000000..a23cc988bdb --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0132.md @@ -0,0 +1,32 @@ +A function with the `start` attribute was declared with type parameters. + +Erroneous code example: + +```compile_fail,E0132 +#![feature(start)] + +#[start] +fn f<T>() {} +``` + +It is not possible to declare type parameters on a function that has the `start` +attribute. Such a function must have the following type signature (for more +information, view [the unstable book][1]): + +[1]: https://doc.rust-lang.org/unstable-book/language-features/lang-items.html#writing-an-executable-without-stdlib + +``` +# let _: +fn(isize, *const *const u8) -> isize; +``` + +Example: + +``` +#![feature(start)] + +#[start] +fn my_start(argc: isize, argv: *const *const u8) -> isize { + 0 +} +``` diff --git a/src/librustc_error_codes/error_codes/E0133.md b/src/librustc_error_codes/error_codes/E0133.md new file mode 100644 index 00000000000..0488cdd808d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0133.md @@ -0,0 +1,31 @@ +Unsafe code was used outside of an unsafe function or block. + +Erroneous code example: + +```compile_fail,E0133 +unsafe fn f() { return; } // This is the unsafe code + +fn main() { + f(); // error: call to unsafe function requires unsafe function or block +} +``` + +Using unsafe functionality is potentially dangerous and disallowed by safety +checks. Examples: + +* Dereferencing raw pointers +* Calling functions via FFI +* Calling functions marked unsafe + +These safety checks can be relaxed for a section of the code by wrapping the +unsafe instructions with an `unsafe` block. For instance: + +``` +unsafe fn f() { return; } + +fn main() { + unsafe { f(); } // ok! +} +``` + +See also https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html diff --git a/src/librustc_error_codes/error_codes/E0136.md b/src/librustc_error_codes/error_codes/E0136.md new file mode 100644 index 00000000000..c0e8c7e061c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0136.md @@ -0,0 +1,16 @@ +A binary can only have one entry point, and by default that entry point is the +function `main()`. If there are multiple such functions, please rename one. + +Erroneous code example: + +```compile_fail,E0136 +fn main() { + // ... +} + +// ... + +fn main() { // error! + // ... +} +``` diff --git a/src/librustc_error_codes/error_codes/E0137.md b/src/librustc_error_codes/error_codes/E0137.md new file mode 100644 index 00000000000..0a02913d236 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0137.md @@ -0,0 +1,24 @@ +More than one function was declared with the `#[main]` attribute. + +Erroneous code example: + +```compile_fail,E0137 +#![feature(main)] + +#[main] +fn foo() {} + +#[main] +fn f() {} // error: multiple functions with a `#[main]` attribute +``` + +This error indicates that the compiler found multiple functions with the +`#[main]` attribute. This is an error because there must be a unique entry +point into a Rust program. Example: + +``` +#![feature(main)] + +#[main] +fn f() {} // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0138.md b/src/librustc_error_codes/error_codes/E0138.md new file mode 100644 index 00000000000..3f5eaea9f98 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0138.md @@ -0,0 +1,25 @@ +More than one function was declared with the `#[start]` attribute. + +Erroneous code example: + +```compile_fail,E0138 +#![feature(start)] + +#[start] +fn foo(argc: isize, argv: *const *const u8) -> isize {} + +#[start] +fn f(argc: isize, argv: *const *const u8) -> isize {} +// error: multiple 'start' functions +``` + +This error indicates that the compiler found multiple functions with the +`#[start]` attribute. This is an error because there must be a unique entry +point into a Rust program. Example: + +``` +#![feature(start)] + +#[start] +fn foo(argc: isize, argv: *const *const u8) -> isize { 0 } // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0139.md b/src/librustc_error_codes/error_codes/E0139.md new file mode 100644 index 00000000000..a116cf29395 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0139.md @@ -0,0 +1,84 @@ +#### Note: this error code is no longer emitted by the compiler. + +There are various restrictions on transmuting between types in Rust; for example +types being transmuted must have the same size. To apply all these restrictions, +the compiler must know the exact types that may be transmuted. When type +parameters are involved, this cannot always be done. + +So, for example, the following is not allowed: + +``` +use std::mem::transmute; + +struct Foo<T>(Vec<T>); + +fn foo<T>(x: Vec<T>) { + // we are transmuting between Vec<T> and Foo<F> here + let y: Foo<T> = unsafe { transmute(x) }; + // do something with y +} +``` + +In this specific case there's a good chance that the transmute is harmless (but +this is not guaranteed by Rust). However, when alignment and enum optimizations +come into the picture, it's quite likely that the sizes may or may not match +with different type parameter substitutions. It's not possible to check this for +_all_ possible types, so `transmute()` simply only accepts types without any +unsubstituted type parameters. + +If you need this, there's a good chance you're doing something wrong. Keep in +mind that Rust doesn't guarantee much about the layout of different structs +(even two structs with identical declarations may have different layouts). If +there is a solution that avoids the transmute entirely, try it instead. + +If it's possible, hand-monomorphize the code by writing the function for each +possible type substitution. It's possible to use traits to do this cleanly, +for example: + +``` +use std::mem::transmute; + +struct Foo<T>(Vec<T>); + +trait MyTransmutableType: Sized { + fn transmute(_: Vec<Self>) -> Foo<Self>; +} + +impl MyTransmutableType for u8 { + fn transmute(x: Vec<u8>) -> Foo<u8> { + unsafe { transmute(x) } + } +} + +impl MyTransmutableType for String { + fn transmute(x: Vec<String>) -> Foo<String> { + unsafe { transmute(x) } + } +} + +// ... more impls for the types you intend to transmute + +fn foo<T: MyTransmutableType>(x: Vec<T>) { + let y: Foo<T> = <T as MyTransmutableType>::transmute(x); + // do something with y +} +``` + +Each impl will be checked for a size match in the transmute as usual, and since +there are no unbound type parameters involved, this should compile unless there +is a size mismatch in one of the impls. + +It is also possible to manually transmute: + +``` +# use std::ptr; +# let v = Some("value"); +# type SomeType = &'static [u8]; +unsafe { + ptr::read(&v as *const _ as *const SomeType) // `v` transmuted to `SomeType` +} +# ; +``` + +Note that this does not move `v` (unlike `transmute`), and may need a +call to `mem::forget(v)` in case you want to avoid destructors being called. diff --git a/src/librustc_error_codes/error_codes/E0152.md b/src/librustc_error_codes/error_codes/E0152.md new file mode 100644 index 00000000000..602dcb6e2c5 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0152.md @@ -0,0 +1,25 @@ +A lang item was redefined. + +Erroneous code example: + +```compile_fail,E0152 +#![feature(lang_items)] + +#[lang = "arc"] +struct Foo; // error: duplicate lang item found: `arc` +``` + +Lang items are already implemented in the standard library. Unless you are +writing a free-standing application (e.g., a kernel), you do not need to provide +them yourself. + +You can build a free-standing crate by adding `#![no_std]` to the crate +attributes: + +```ignore (only-for-syntax-highlight) +#![no_std] +``` + +See also the [unstable book][1]. + +[1]: https://doc.rust-lang.org/unstable-book/language-features/lang-items.html#writing-an-executable-without-stdlib diff --git a/src/librustc_error_codes/error_codes/E0154.md b/src/librustc_error_codes/error_codes/E0154.md new file mode 100644 index 00000000000..725a775e72c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0154.md @@ -0,0 +1,33 @@ +#### Note: this error code is no longer emitted by the compiler. + +Imports (`use` statements) are not allowed after non-item statements, such as +variable declarations and expression statements. + +Here is an example that demonstrates the error: + +``` +fn f() { + // Variable declaration before import + let x = 0; + use std::io::Read; + // ... +} +``` + +The solution is to declare the imports at the top of the block, function, or +file. + +Here is the previous example again, with the correct order: + +``` +fn f() { + use std::io::Read; + let x = 0; + // ... +} +``` + +See the Declaration Statements section of the reference for more information +about what constitutes an Item declaration and what does not: + +https://doc.rust-lang.org/reference.html#statements diff --git a/src/librustc_error_codes/error_codes/E0158.md b/src/librustc_error_codes/error_codes/E0158.md new file mode 100644 index 00000000000..0a9ef9c3938 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0158.md @@ -0,0 +1,38 @@ +An associated const has been referenced in a pattern. + +Erroneous code example: + +```compile_fail,E0158 +enum EFoo { A, B, C, D } + +trait Foo { + const X: EFoo; +} + +fn test<A: Foo>(arg: EFoo) { + match arg { + A::X => { // error! + println!("A::X"); + } + } +} +``` + +`const` and `static` mean different things. A `const` is a compile-time +constant, an alias for a literal value. This property means you can match it +directly within a pattern. + +The `static` keyword, on the other hand, guarantees a fixed location in memory. +This does not always mean that the value is constant. For example, a global +mutex can be declared `static` as well. + +If you want to match against a `static`, consider using a guard instead: + +``` +static FORTY_TWO: i32 = 42; + +match Some(42) { + Some(x) if x == FORTY_TWO => {} + _ => {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0161.md b/src/librustc_error_codes/error_codes/E0161.md new file mode 100644 index 00000000000..26269db2327 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0161.md @@ -0,0 +1,30 @@ +A value was moved. However, its size was not known at compile time, and only +values of a known size can be moved. + +Erroneous code example: + +```compile_fail,E0161 +#![feature(box_syntax)] + +fn main() { + let array: &[isize] = &[1, 2, 3]; + let _x: Box<[isize]> = box *array; + // error: cannot move a value of type [isize]: the size of [isize] cannot + // be statically determined +} +``` + +In Rust, you can only move a value when its size is known at compile time. + +To work around this restriction, consider "hiding" the value behind a reference: +either `&x` or `&mut x`. Since a reference has a fixed size, this lets you move +it around as usual. Example: + +``` +#![feature(box_syntax)] + +fn main() { + let array: &[isize] = &[1, 2, 3]; + let _x: Box<&[isize]> = box array; // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0162.md b/src/librustc_error_codes/error_codes/E0162.md new file mode 100644 index 00000000000..98146147f39 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0162.md @@ -0,0 +1,26 @@ +#### Note: this error code is no longer emitted by the compiler. + +An if-let pattern attempts to match the pattern, and enters the body if the +match was successful. If the match is irrefutable (when it cannot fail to +match), use a regular `let`-binding instead. For instance: + +``` +struct Irrefutable(i32); +let irr = Irrefutable(0); + +// This fails to compile because the match is irrefutable. +if let Irrefutable(x) = irr { + // This body will always be executed. + // ... +} +``` + +Try this instead: + +``` +struct Irrefutable(i32); +let irr = Irrefutable(0); + +let Irrefutable(x) = irr; +println!("{}", x); +``` diff --git a/src/librustc_error_codes/error_codes/E0164.md b/src/librustc_error_codes/error_codes/E0164.md new file mode 100644 index 00000000000..b41ce6fad8e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0164.md @@ -0,0 +1,24 @@ +This error means that an attempt was made to match a struct type enum +variant as a non-struct type: + +```compile_fail,E0164 +enum Foo { B { i: u32 } } + +fn bar(foo: Foo) -> u32 { + match foo { + Foo::B(i) => i, // error E0164 + } +} +``` + +Try using `{}` instead: + +``` +enum Foo { B { i: u32 } } + +fn bar(foo: Foo) -> u32 { + match foo { + Foo::B{i} => i, + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0165.md b/src/librustc_error_codes/error_codes/E0165.md new file mode 100644 index 00000000000..92243db4550 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0165.md @@ -0,0 +1,27 @@ +#### Note: this error code is no longer emitted by the compiler. + +A while-let pattern attempts to match the pattern, and enters the body if the +match was successful. If the match is irrefutable (when it cannot fail to +match), use a regular `let`-binding inside a `loop` instead. For instance: + +```no_run +struct Irrefutable(i32); +let irr = Irrefutable(0); + +// This fails to compile because the match is irrefutable. +while let Irrefutable(x) = irr { + // ... +} +``` + +Try this instead: + +```no_run +struct Irrefutable(i32); +let irr = Irrefutable(0); + +loop { + let Irrefutable(x) = irr; + // ... +} +``` diff --git a/src/librustc_error_codes/error_codes/E0170.md b/src/librustc_error_codes/error_codes/E0170.md new file mode 100644 index 00000000000..4b870dbf221 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0170.md @@ -0,0 +1,46 @@ +Enum variants are qualified by default. For example, given this type: + +``` +enum Method { + GET, + POST, +} +``` + +You would match it using: + +``` +enum Method { + GET, + POST, +} + +let m = Method::GET; + +match m { + Method::GET => {}, + Method::POST => {}, +} +``` + +If you don't qualify the names, the code will bind new variables named "GET" and +"POST" instead. This behavior is likely not what you want, so `rustc` warns when +that happens. + +Qualified names are good practice, and most code works well with them. But if +you prefer them unqualified, you can import the variants into scope: + +``` +use Method::*; +enum Method { GET, POST } +# fn main() {} +``` + +If you want others to be able to import variants from your module directly, use +`pub use`: + +``` +pub use Method::*; +pub enum Method { GET, POST } +# fn main() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0178.md b/src/librustc_error_codes/error_codes/E0178.md new file mode 100644 index 00000000000..07980ad83f1 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0178.md @@ -0,0 +1,19 @@ +In types, the `+` type operator has low precedence, so it is often necessary +to use parentheses. + +For example: + +```compile_fail,E0178 +trait Foo {} + +struct Bar<'a> { + w: &'a Foo + Copy, // error, use &'a (Foo + Copy) + x: &'a Foo + 'a, // error, use &'a (Foo + 'a) + y: &'a mut Foo + 'a, // error, use &'a mut (Foo + 'a) + z: fn() -> Foo + 'a, // error, use fn() -> (Foo + 'a) +} +``` + +More details can be found in [RFC 438]. + +[RFC 438]: https://github.com/rust-lang/rfcs/pull/438 diff --git a/src/librustc_error_codes/error_codes/E0184.md b/src/librustc_error_codes/error_codes/E0184.md new file mode 100644 index 00000000000..e7fa8dfd831 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0184.md @@ -0,0 +1,6 @@ +Explicitly implementing both Drop and Copy for a type is currently disallowed. +This feature can make some sense in theory, but the current implementation is +incorrect and can lead to memory unsafety (see [issue #20126][iss20126]), so +it has been disabled for now. + +[iss20126]: https://github.com/rust-lang/rust/issues/20126 diff --git a/src/librustc_error_codes/error_codes/E0185.md b/src/librustc_error_codes/error_codes/E0185.md new file mode 100644 index 00000000000..f0ad2af144a --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0185.md @@ -0,0 +1,19 @@ +An associated function for a trait was defined to be static, but an +implementation of the trait declared the same function to be a method (i.e., to +take a `self` parameter). + +Here's an example of this error: + +```compile_fail,E0185 +trait Foo { + fn foo(); +} + +struct Bar; + +impl Foo for Bar { + // error, method `foo` has a `&self` declaration in the impl, but not in + // the trait + fn foo(&self) {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0186.md b/src/librustc_error_codes/error_codes/E0186.md new file mode 100644 index 00000000000..9135d5c1d5e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0186.md @@ -0,0 +1,19 @@ +An associated function for a trait was defined to be a method (i.e., to take a +`self` parameter), but an implementation of the trait declared the same function +to be static. + +Here's an example of this error: + +```compile_fail,E0186 +trait Foo { + fn foo(&self); +} + +struct Bar; + +impl Foo for Bar { + // error, method `foo` has a `&self` declaration in the trait, but not in + // the impl + fn foo() {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0191.md b/src/librustc_error_codes/error_codes/E0191.md new file mode 100644 index 00000000000..b79196f6cec --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0191.md @@ -0,0 +1,22 @@ +Trait objects need to have all associated types specified. Erroneous code +example: + +```compile_fail,E0191 +trait Trait { + type Bar; +} + +type Foo = Trait; // error: the value of the associated type `Bar` (from + // the trait `Trait`) must be specified +``` + +Please verify you specified all associated types of the trait and that you +used the right trait. Example: + +``` +trait Trait { + type Bar; +} + +type Foo = Trait<Bar=i32>; // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0192.md b/src/librustc_error_codes/error_codes/E0192.md new file mode 100644 index 00000000000..33308868cb2 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0192.md @@ -0,0 +1,4 @@ +Negative impls are only allowed for auto traits. For more +information see the [opt-in builtin traits RFC][RFC 19]. + +[RFC 19]: https://github.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md diff --git a/src/librustc_error_codes/error_codes/E0193.md b/src/librustc_error_codes/error_codes/E0193.md new file mode 100644 index 00000000000..e29a949ffba --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0193.md @@ -0,0 +1,44 @@ +#### Note: this error code is no longer emitted by the compiler. + +`where` clauses must use generic type parameters: it does not make sense to use +them otherwise. An example causing this error: + +``` +trait Foo { + fn bar(&self); +} + +#[derive(Copy,Clone)] +struct Wrapper<T> { + Wrapped: T +} + +impl Foo for Wrapper<u32> where Wrapper<u32>: Clone { + fn bar(&self) { } +} +``` + +This use of a `where` clause is strange - a more common usage would look +something like the following: + +``` +trait Foo { + fn bar(&self); +} + +#[derive(Copy,Clone)] +struct Wrapper<T> { + Wrapped: T +} +impl <T> Foo for Wrapper<T> where Wrapper<T>: Clone { + fn bar(&self) { } +} +``` + +Here, we're saying that the implementation exists on Wrapper only when the +wrapped type `T` implements `Clone`. The `where` clause is important because +some types will not implement `Clone`, and thus will not get this method. + +In our erroneous example, however, we're referencing a single concrete type. +Since we know for certain that `Wrapper<u32>` implements `Clone`, there's no +reason to also specify it in a `where` clause. diff --git a/src/librustc_error_codes/error_codes/E0195.md b/src/librustc_error_codes/error_codes/E0195.md new file mode 100644 index 00000000000..3606521020a --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0195.md @@ -0,0 +1,34 @@ +Your method's lifetime parameters do not match the trait declaration. +Erroneous code example: + +```compile_fail,E0195 +trait Trait { + fn bar<'a,'b:'a>(x: &'a str, y: &'b str); +} + +struct Foo; + +impl Trait for Foo { + fn bar<'a,'b>(x: &'a str, y: &'b str) { + // error: lifetime parameters or bounds on method `bar` + // do not match the trait declaration + } +} +``` + +The lifetime constraint `'b` for bar() implementation does not match the +trait declaration. Ensure lifetime declarations match exactly in both trait +declaration and implementation. Example: + +``` +trait Trait { + fn t<'a,'b:'a>(x: &'a str, y: &'b str); +} + +struct Foo; + +impl Trait for Foo { + fn t<'a,'b:'a>(x: &'a str, y: &'b str) { // ok! + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0197.md b/src/librustc_error_codes/error_codes/E0197.md new file mode 100644 index 00000000000..0d91157e572 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0197.md @@ -0,0 +1,13 @@ +Inherent implementations (one that do not implement a trait but provide +methods associated with a type) are always safe because they are not +implementing an unsafe trait. Removing the `unsafe` keyword from the inherent +implementation will resolve this error. + +```compile_fail,E0197 +struct Foo; + +// this will cause this error +unsafe impl Foo { } +// converting it to this will fix it +impl Foo { } +``` diff --git a/src/librustc_error_codes/error_codes/E0198.md b/src/librustc_error_codes/error_codes/E0198.md new file mode 100644 index 00000000000..6504d60dbd1 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0198.md @@ -0,0 +1,27 @@ +A negative implementation is one that excludes a type from implementing a +particular trait. Not being able to use a trait is always a safe operation, +so negative implementations are always safe and never need to be marked as +unsafe. + +```compile_fail +#![feature(optin_builtin_traits)] + +struct Foo; + +// unsafe is unnecessary +unsafe impl !Clone for Foo { } +``` + +This will compile: + +```ignore (ignore auto_trait future compatibility warning) +#![feature(optin_builtin_traits)] + +struct Foo; + +auto trait Enterprise {} + +impl !Enterprise for Foo { } +``` + +Please note that negative impls are only allowed for auto traits. diff --git a/src/librustc_error_codes/error_codes/E0199.md b/src/librustc_error_codes/error_codes/E0199.md new file mode 100644 index 00000000000..d0c12dc6f17 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0199.md @@ -0,0 +1,14 @@ +Safe traits should not have unsafe implementations, therefore marking an +implementation for a safe trait unsafe will cause a compiler error. Removing +the unsafe marker on the trait noted in the error will resolve this problem. + +```compile_fail,E0199 +struct Foo; + +trait Bar { } + +// this won't compile because Bar is safe +unsafe impl Bar for Foo { } +// this will compile +impl Bar for Foo { } +``` diff --git a/src/librustc_error_codes/error_codes/E0200.md b/src/librustc_error_codes/error_codes/E0200.md new file mode 100644 index 00000000000..865e91430ac --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0200.md @@ -0,0 +1,14 @@ +Unsafe traits must have unsafe implementations. This error occurs when an +implementation for an unsafe trait isn't marked as unsafe. This may be resolved +by marking the unsafe implementation as unsafe. + +```compile_fail,E0200 +struct Foo; + +unsafe trait Bar { } + +// this won't compile because Bar is unsafe and impl isn't unsafe +impl Bar for Foo { } +// this will compile +unsafe impl Bar for Foo { } +``` diff --git a/src/librustc_error_codes/error_codes/E0201.md b/src/librustc_error_codes/error_codes/E0201.md new file mode 100644 index 00000000000..bdbf02f0033 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0201.md @@ -0,0 +1,45 @@ +It is an error to define two associated items (like methods, associated types, +associated functions, etc.) with the same identifier. + +For example: + +```compile_fail,E0201 +struct Foo(u8); + +impl Foo { + fn bar(&self) -> bool { self.0 > 5 } + fn bar() {} // error: duplicate associated function +} + +trait Baz { + type Quux; + fn baz(&self) -> bool; +} + +impl Baz for Foo { + type Quux = u32; + + fn baz(&self) -> bool { true } + + // error: duplicate method + fn baz(&self) -> bool { self.0 > 5 } + + // error: duplicate associated type + type Quux = u32; +} +``` + +Note, however, that items with the same name are allowed for inherent `impl` +blocks that don't overlap: + +``` +struct Foo<T>(T); + +impl Foo<u8> { + fn bar(&self) -> bool { self.0 > 5 } +} + +impl Foo<bool> { + fn bar(&self) -> bool { self.0 } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0202.md b/src/librustc_error_codes/error_codes/E0202.md new file mode 100644 index 00000000000..b20d338c5fd --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0202.md @@ -0,0 +1,5 @@ +Inherent associated types were part of [RFC 195] but are not yet implemented. +See [the tracking issue][iss8995] for the status of this implementation. + +[RFC 195]: https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-items.md +[iss8995]: https://github.com/rust-lang/rust/issues/8995 diff --git a/src/librustc_error_codes/error_codes/E0204.md b/src/librustc_error_codes/error_codes/E0204.md new file mode 100644 index 00000000000..31569011135 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0204.md @@ -0,0 +1,25 @@ +An attempt to implement the `Copy` trait for a struct failed because one of the +fields does not implement `Copy`. To fix this, you must implement `Copy` for the +mentioned field. Note that this may not be possible, as in the example of + +```compile_fail,E0204 +struct Foo { + foo : Vec<u32>, +} + +impl Copy for Foo { } +``` + +This fails because `Vec<T>` does not implement `Copy` for any `T`. + +Here's another example that will fail: + +```compile_fail,E0204 +#[derive(Copy)] +struct Foo<'a> { + ty: &'a mut bool, +} +``` + +This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this +differs from the behavior for `&T`, which is always `Copy`). diff --git a/src/librustc_error_codes/error_codes/E0205.md b/src/librustc_error_codes/error_codes/E0205.md new file mode 100644 index 00000000000..7916f53ad3b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0205.md @@ -0,0 +1,29 @@ +#### Note: this error code is no longer emitted by the compiler. + +An attempt to implement the `Copy` trait for an enum failed because one of the +variants does not implement `Copy`. To fix this, you must implement `Copy` for +the mentioned variant. Note that this may not be possible, as in the example of + +```compile_fail,E0204 +enum Foo { + Bar(Vec<u32>), + Baz, +} + +impl Copy for Foo { } +``` + +This fails because `Vec<T>` does not implement `Copy` for any `T`. + +Here's another example that will fail: + +```compile_fail,E0204 +#[derive(Copy)] +enum Foo<'a> { + Bar(&'a mut bool), + Baz, +} +``` + +This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this +differs from the behavior for `&T`, which is always `Copy`). diff --git a/src/librustc_error_codes/error_codes/E0206.md b/src/librustc_error_codes/error_codes/E0206.md new file mode 100644 index 00000000000..fc4c0e07a16 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0206.md @@ -0,0 +1,12 @@ +You can only implement `Copy` for a struct or enum. Both of the following +examples will fail, because neither `[u8; 256]` nor `&'static mut Bar` +(mutable reference to `Bar`) is a struct or enum: + +```compile_fail,E0206 +type Foo = [u8; 256]; +impl Copy for Foo { } // error + +#[derive(Copy, Clone)] +struct Bar; +impl Copy for &'static mut Bar { } // error +``` diff --git a/src/librustc_error_codes/error_codes/E0207.md b/src/librustc_error_codes/error_codes/E0207.md new file mode 100644 index 00000000000..67b2063504c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0207.md @@ -0,0 +1,131 @@ +Any type parameter or lifetime parameter of an `impl` must meet at least one of +the following criteria: + + - it appears in the _implementing type_ of the impl, e.g. `impl<T> Foo<T>` + - for a trait impl, it appears in the _implemented trait_, e.g. + `impl<T> SomeTrait<T> for Foo` + - it is bound as an associated type, e.g. `impl<T, U> SomeTrait for T + where T: AnotherTrait<AssocType=U>` + +### Error example 1 + +Suppose we have a struct `Foo` and we would like to define some methods for it. +The following definition leads to a compiler error: + +```compile_fail,E0207 +struct Foo; + +impl<T: Default> Foo { +// error: the type parameter `T` is not constrained by the impl trait, self +// type, or predicates [E0207] + fn get(&self) -> T { + <T as Default>::default() + } +} +``` + +The problem is that the parameter `T` does not appear in the implementing type +(`Foo`) of the impl. In this case, we can fix the error by moving the type +parameter from the `impl` to the method `get`: + + +``` +struct Foo; + +// Move the type parameter from the impl to the method +impl Foo { + fn get<T: Default>(&self) -> T { + <T as Default>::default() + } +} +``` + +### Error example 2 + +As another example, suppose we have a `Maker` trait and want to establish a +type `FooMaker` that makes `Foo`s: + +```compile_fail,E0207 +trait Maker { + type Item; + fn make(&mut self) -> Self::Item; +} + +struct Foo<T> { + foo: T +} + +struct FooMaker; + +impl<T: Default> Maker for FooMaker { +// error: the type parameter `T` is not constrained by the impl trait, self +// type, or predicates [E0207] + type Item = Foo<T>; + + fn make(&mut self) -> Foo<T> { + Foo { foo: <T as Default>::default() } + } +} +``` + +This fails to compile because `T` does not appear in the trait or in the +implementing type. + +One way to work around this is to introduce a phantom type parameter into +`FooMaker`, like so: + +``` +use std::marker::PhantomData; + +trait Maker { + type Item; + fn make(&mut self) -> Self::Item; +} + +struct Foo<T> { + foo: T +} + +// Add a type parameter to `FooMaker` +struct FooMaker<T> { + phantom: PhantomData<T>, +} + +impl<T: Default> Maker for FooMaker<T> { + type Item = Foo<T>; + + fn make(&mut self) -> Foo<T> { + Foo { + foo: <T as Default>::default(), + } + } +} +``` + +Another way is to do away with the associated type in `Maker` and use an input +type parameter instead: + +``` +// Use a type parameter instead of an associated type here +trait Maker<Item> { + fn make(&mut self) -> Item; +} + +struct Foo<T> { + foo: T +} + +struct FooMaker; + +impl<T: Default> Maker<Foo<T>> for FooMaker { + fn make(&mut self) -> Foo<T> { + Foo { foo: <T as Default>::default() } + } +} +``` + +### Additional information + +For more information, please see [RFC 447]. + +[RFC 447]: https://github.com/rust-lang/rfcs/blob/master/text/0447-no-unused-impl-parameters.md diff --git a/src/librustc_error_codes/error_codes/E0210.md b/src/librustc_error_codes/error_codes/E0210.md new file mode 100644 index 00000000000..dc2fd9b0ca0 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0210.md @@ -0,0 +1,82 @@ +This error indicates a violation of one of Rust's orphan rules for trait +implementations. The rule concerns the use of type parameters in an +implementation of a foreign trait (a trait defined in another crate), and +states that type parameters must be "covered" by a local type. + +When implementing a foreign trait for a foreign type, +the trait must have one or more type parameters. +A type local to your crate must appear before any use of any type parameters. + +To understand what this means, it is perhaps easier to consider a few examples. + +If `ForeignTrait` is a trait defined in some external crate `foo`, then the +following trait `impl` is an error: + +```compile_fail,E0210 +# #[cfg(for_demonstration_only)] +extern crate foo; +# #[cfg(for_demonstration_only)] +use foo::ForeignTrait; +# use std::panic::UnwindSafe as ForeignTrait; + +impl<T> ForeignTrait for T { } // error +# fn main() {} +``` + +To work around this, it can be covered with a local type, `MyType`: + +``` +# use std::panic::UnwindSafe as ForeignTrait; +struct MyType<T>(T); +impl<T> ForeignTrait for MyType<T> { } // Ok +``` + +Please note that a type alias is not sufficient. + +For another example of an error, suppose there's another trait defined in `foo` +named `ForeignTrait2` that takes two type parameters. Then this `impl` results +in the same rule violation: + +```ignore (cannot-doctest-multicrate-project) +struct MyType2; +impl<T> ForeignTrait2<T, MyType<T>> for MyType2 { } // error +``` + +The reason for this is that there are two appearances of type parameter `T` in +the `impl` header, both as parameters for `ForeignTrait2`. The first appearance +is uncovered, and so runs afoul of the orphan rule. + +Consider one more example: + +```ignore (cannot-doctest-multicrate-project) +impl<T> ForeignTrait2<MyType<T>, T> for MyType2 { } // Ok +``` + +This only differs from the previous `impl` in that the parameters `T` and +`MyType<T>` for `ForeignTrait2` have been swapped. This example does *not* +violate the orphan rule; it is permitted. + +To see why that last example was allowed, you need to understand the general +rule. Unfortunately this rule is a bit tricky to state. Consider an `impl`: + +```ignore (only-for-syntax-highlight) +impl<P1, ..., Pm> ForeignTrait<T1, ..., Tn> for T0 { ... } +``` + +where `P1, ..., Pm` are the type parameters of the `impl` and `T0, ..., Tn` +are types. One of the types `T0, ..., Tn` must be a local type (this is another +orphan rule, see the explanation for E0117). + +Both of the following must be true: +1. At least one of the types `T0..=Tn` must be a local type. +Let `Ti` be the first such type. +2. No uncovered type parameters `P1..=Pm` may appear in `T0..Ti` +(excluding `Ti`). + +For information on the design of the orphan rules, +see [RFC 2451] and [RFC 1023]. + +For information on the design of the orphan rules, see [RFC 1023]. + +[RFC 2451]: https://rust-lang.github.io/rfcs/2451-re-rebalancing-coherence.html +[RFC 1023]: https://github.com/rust-lang/rfcs/blob/master/text/1023-rebalancing-coherence.md diff --git a/src/librustc_error_codes/error_codes/E0211.md b/src/librustc_error_codes/error_codes/E0211.md new file mode 100644 index 00000000000..77289f01900 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0211.md @@ -0,0 +1,79 @@ +#### Note: this error code is no longer emitted by the compiler. + +You used a function or type which doesn't fit the requirements for where it was +used. Erroneous code examples: + +```compile_fail +#![feature(intrinsics)] + +extern "rust-intrinsic" { + fn size_of<T>(); // error: intrinsic has wrong type +} + +// or: + +fn main() -> i32 { 0 } +// error: main function expects type: `fn() {main}`: expected (), found i32 + +// or: + +let x = 1u8; +match x { + 0u8..=3i8 => (), + // error: mismatched types in range: expected u8, found i8 + _ => () +} + +// or: + +use std::rc::Rc; +struct Foo; + +impl Foo { + fn x(self: Rc<Foo>) {} + // error: mismatched self type: expected `Foo`: expected struct + // `Foo`, found struct `alloc::rc::Rc` +} +``` + +For the first code example, please check the function definition. Example: + +``` +#![feature(intrinsics)] + +extern "rust-intrinsic" { + fn size_of<T>() -> usize; // ok! +} +``` + +The second case example is a bit particular: the main function must always +have this definition: + +```compile_fail +fn main(); +``` + +They never take parameters and never return types. + +For the third example, when you match, all patterns must have the same type +as the type you're matching on. Example: + +``` +let x = 1u8; + +match x { + 0u8..=3u8 => (), // ok! + _ => () +} +``` + +And finally, for the last example, only `Box<Self>`, `&Self`, `Self`, +or `&mut Self` work as explicit self parameters. Example: + +``` +struct Foo; + +impl Foo { + fn x(self: Box<Foo>) {} // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0214.md b/src/librustc_error_codes/error_codes/E0214.md new file mode 100644 index 00000000000..f78c1c0cd01 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0214.md @@ -0,0 +1,12 @@ +A generic type was described using parentheses rather than angle brackets. +For example: + +```compile_fail,E0214 +fn main() { + let v: Vec(&str) = vec!["foo"]; +} +``` + +This is not currently supported: `v` should be defined as `Vec<&str>`. +Parentheses are currently only used with generic types when defining parameters +for `Fn`-family traits. diff --git a/src/librustc_error_codes/error_codes/E0220.md b/src/librustc_error_codes/error_codes/E0220.md new file mode 100644 index 00000000000..43e075b522b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0220.md @@ -0,0 +1,41 @@ +You used an associated type which isn't defined in the trait. +Erroneous code example: + +```compile_fail,E0220 +trait T1 { + type Bar; +} + +type Foo = T1<F=i32>; // error: associated type `F` not found for `T1` + +// or: + +trait T2 { + type Bar; + + // error: Baz is used but not declared + fn return_bool(&self, _: &Self::Bar, _: &Self::Baz) -> bool; +} +``` + +Make sure that you have defined the associated type in the trait body. +Also, verify that you used the right trait or you didn't misspell the +associated type name. Example: + +``` +trait T1 { + type Bar; +} + +type Foo = T1<Bar=i32>; // ok! + +// or: + +trait T2 { + type Bar; + type Baz; // we declare `Baz` in our trait. + + // and now we can use it here: + fn return_bool(&self, _: &Self::Bar, _: &Self::Baz) -> bool; +} +``` diff --git a/src/librustc_error_codes/error_codes/E0221.md b/src/librustc_error_codes/error_codes/E0221.md new file mode 100644 index 00000000000..53fabf490e2 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0221.md @@ -0,0 +1,43 @@ +An attempt was made to retrieve an associated type, but the type was ambiguous. +For example: + +```compile_fail,E0221 +trait T1 {} +trait T2 {} + +trait Foo { + type A: T1; +} + +trait Bar : Foo { + type A: T2; + fn do_something() { + let _: Self::A; + } +} +``` + +In this example, `Foo` defines an associated type `A`. `Bar` inherits that type +from `Foo`, and defines another associated type of the same name. As a result, +when we attempt to use `Self::A`, it's ambiguous whether we mean the `A` defined +by `Foo` or the one defined by `Bar`. + +There are two options to work around this issue. The first is simply to rename +one of the types. Alternatively, one can specify the intended type using the +following syntax: + +``` +trait T1 {} +trait T2 {} + +trait Foo { + type A: T1; +} + +trait Bar : Foo { + type A: T2; + fn do_something() { + let _: <Self as Bar>::A; + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0223.md b/src/librustc_error_codes/error_codes/E0223.md new file mode 100644 index 00000000000..9fe03604255 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0223.md @@ -0,0 +1,32 @@ +An attempt was made to retrieve an associated type, but the type was ambiguous. +For example: + +```compile_fail,E0223 +trait MyTrait {type X; } + +fn main() { + let foo: MyTrait::X; +} +``` + +The problem here is that we're attempting to take the type of X from MyTrait. +Unfortunately, the type of X is not defined, because it's only made concrete in +implementations of the trait. A working version of this code might look like: + +``` +trait MyTrait {type X; } +struct MyStruct; + +impl MyTrait for MyStruct { + type X = u32; +} + +fn main() { + let foo: <MyStruct as MyTrait>::X; +} +``` + +This syntax specifies that we want the X type from MyTrait, as made concrete in +MyStruct. The reason that we cannot simply use `MyStruct::X` is that MyStruct +might implement two different traits with identically-named associated types. +This syntax allows disambiguation between the two. diff --git a/src/librustc_error_codes/error_codes/E0225.md b/src/librustc_error_codes/error_codes/E0225.md new file mode 100644 index 00000000000..b9820dc68ee --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0225.md @@ -0,0 +1,18 @@ +You attempted to use multiple types as bounds for a closure or trait object. +Rust does not currently support this. A simple example that causes this error: + +```compile_fail,E0225 +fn main() { + let _: Box<dyn std::io::Read + std::io::Write>; +} +``` + +Auto traits such as Send and Sync are an exception to this rule: +It's possible to have bounds of one non-builtin trait, plus any number of +auto traits. For example, the following compiles correctly: + +``` +fn main() { + let _: Box<dyn std::io::Read + Send + Sync>; +} +``` diff --git a/src/librustc_error_codes/error_codes/E0229.md b/src/librustc_error_codes/error_codes/E0229.md new file mode 100644 index 00000000000..a8bd341a62b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0229.md @@ -0,0 +1,36 @@ +An associated type binding was done outside of the type parameter declaration +and `where` clause. Erroneous code example: + +```compile_fail,E0229 +pub trait Foo { + type A; + fn boo(&self) -> <Self as Foo>::A; +} + +struct Bar; + +impl Foo for isize { + type A = usize; + fn boo(&self) -> usize { 42 } +} + +fn baz<I>(x: &<I as Foo<A=Bar>>::A) {} +// error: associated type bindings are not allowed here +``` + +To solve this error, please move the type bindings in the type parameter +declaration: + +``` +# struct Bar; +# trait Foo { type A; } +fn baz<I: Foo<A=Bar>>(x: &<I as Foo>::A) {} // ok! +``` + +Or in the `where` clause: + +``` +# struct Bar; +# trait Foo { type A; } +fn baz<I>(x: &<I as Foo>::A) where I: Foo<A=Bar> {} +``` diff --git a/src/librustc_error_codes/error_codes/E0230.md b/src/librustc_error_codes/error_codes/E0230.md new file mode 100644 index 00000000000..9dbcb8e010b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0230.md @@ -0,0 +1,29 @@ +The `#[rustc_on_unimplemented]` attribute lets you specify a custom error +message for when a particular trait isn't implemented on a type placed in a +position that needs that trait. For example, when the following code is +compiled: + +```compile_fail +#![feature(rustc_attrs)] + +fn foo<T: Index<u8>>(x: T){} + +#[rustc_on_unimplemented = "the type `{Self}` cannot be indexed by `{Idx}`"] +trait Index<Idx> { /* ... */ } + +foo(true); // `bool` does not implement `Index<u8>` +``` + +There will be an error about `bool` not implementing `Index<u8>`, followed by a +note saying "the type `bool` cannot be indexed by `u8`". + +As you can see, you can specify type parameters in curly braces for +substitution with the actual types (using the regular format string syntax) in +a given situation. Furthermore, `{Self}` will substitute to the type (in this +case, `bool`) that we tried to use. + +This error appears when the curly braces contain an identifier which doesn't +match with any of the type parameters or the string `Self`. This might happen +if you misspelled a type parameter, or if you intended to use literal curly +braces. If it is the latter, escape the curly braces with a second curly brace +of the same type; e.g., a literal `{` is `{{`. diff --git a/src/librustc_error_codes/error_codes/E0231.md b/src/librustc_error_codes/error_codes/E0231.md new file mode 100644 index 00000000000..4f80da54540 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0231.md @@ -0,0 +1,27 @@ +The `#[rustc_on_unimplemented]` attribute lets you specify a custom error +message for when a particular trait isn't implemented on a type placed in a +position that needs that trait. For example, when the following code is +compiled: + +```compile_fail +#![feature(rustc_attrs)] + +fn foo<T: Index<u8>>(x: T){} + +#[rustc_on_unimplemented = "the type `{Self}` cannot be indexed by `{Idx}`"] +trait Index<Idx> { /* ... */ } + +foo(true); // `bool` does not implement `Index<u8>` +``` + +there will be an error about `bool` not implementing `Index<u8>`, followed by a +note saying "the type `bool` cannot be indexed by `u8`". + +As you can see, you can specify type parameters in curly braces for +substitution with the actual types (using the regular format string syntax) in +a given situation. Furthermore, `{Self}` will substitute to the type (in this +case, `bool`) that we tried to use. + +This error appears when the curly braces do not contain an identifier. Please +add one of the same name as a type parameter. If you intended to use literal +braces, use `{{` and `}}` to escape them. diff --git a/src/librustc_error_codes/error_codes/E0232.md b/src/librustc_error_codes/error_codes/E0232.md new file mode 100644 index 00000000000..07a031488d0 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0232.md @@ -0,0 +1,22 @@ +The `#[rustc_on_unimplemented]` attribute lets you specify a custom error +message for when a particular trait isn't implemented on a type placed in a +position that needs that trait. For example, when the following code is +compiled: + +```compile_fail +#![feature(rustc_attrs)] + +fn foo<T: Index<u8>>(x: T){} + +#[rustc_on_unimplemented = "the type `{Self}` cannot be indexed by `{Idx}`"] +trait Index<Idx> { /* ... */ } + +foo(true); // `bool` does not implement `Index<u8>` +``` + +there will be an error about `bool` not implementing `Index<u8>`, followed by a +note saying "the type `bool` cannot be indexed by `u8`". + +For this to work, some note must be specified. An empty attribute will not do +anything, please remove the attribute or add some helpful note for users of the +trait. diff --git a/src/librustc_error_codes/error_codes/E0243.md b/src/librustc_error_codes/error_codes/E0243.md new file mode 100644 index 00000000000..5d3d1828bf5 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0243.md @@ -0,0 +1,13 @@ +#### Note: this error code is no longer emitted by the compiler. + +This error indicates that not enough type parameters were found in a type or +trait. + +For example, the `Foo` struct below is defined to be generic in `T`, but the +type parameter is missing in the definition of `Bar`: + +```compile_fail,E0107 +struct Foo<T> { x: T } + +struct Bar { x: Foo } +``` diff --git a/src/librustc_error_codes/error_codes/E0244.md b/src/librustc_error_codes/error_codes/E0244.md new file mode 100644 index 00000000000..5187b7b05d2 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0244.md @@ -0,0 +1,13 @@ +#### Note: this error code is no longer emitted by the compiler. + +This error indicates that too many type parameters were found in a type or +trait. + +For example, the `Foo` struct below has no type parameters, but is supplied +with two in the definition of `Bar`: + +```compile_fail,E0107 +struct Foo { x: bool } + +struct Bar<S, T> { x: Foo<S, T> } +``` diff --git a/src/librustc_error_codes/error_codes/E0251.md b/src/librustc_error_codes/error_codes/E0251.md new file mode 100644 index 00000000000..4121dd27877 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0251.md @@ -0,0 +1,21 @@ +#### Note: this error code is no longer emitted by the compiler. + +Two items of the same name cannot be imported without rebinding one of the +items under a new local name. + +An example of this error: + +``` +use foo::baz; +use bar::*; // error, do `use foo::baz as quux` instead on the previous line + +fn main() {} + +mod foo { + pub struct baz; +} + +mod bar { + pub mod baz {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0252.md b/src/librustc_error_codes/error_codes/E0252.md new file mode 100644 index 00000000000..e678944650f --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0252.md @@ -0,0 +1,54 @@ +Two items of the same name cannot be imported without rebinding one of the +items under a new local name. + +Erroneous code example: + +```compile_fail,E0252 +use foo::baz; +use bar::baz; // error, do `use bar::baz as quux` instead + +fn main() {} + +mod foo { + pub struct baz; +} + +mod bar { + pub mod baz {} +} +``` + +You can use aliases in order to fix this error. Example: + +``` +use foo::baz as foo_baz; +use bar::baz; // ok! + +fn main() {} + +mod foo { + pub struct baz; +} + +mod bar { + pub mod baz {} +} +``` + +Or you can reference the item with its parent: + +``` +use bar::baz; + +fn main() { + let x = foo::baz; // ok! +} + +mod foo { + pub struct baz; +} + +mod bar { + pub mod baz {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0253.md b/src/librustc_error_codes/error_codes/E0253.md new file mode 100644 index 00000000000..aea51d40238 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0253.md @@ -0,0 +1,19 @@ +Attempt was made to import an unimportable value. This can happen when trying +to import a method from a trait. + +Erroneous code example: + +```compile_fail,E0253 +mod foo { + pub trait MyTrait { + fn do_something(); + } +} + +use foo::MyTrait::do_something; +// error: `do_something` is not directly importable + +fn main() {} +``` + +It's invalid to directly import methods belonging to a trait or concrete type. diff --git a/src/librustc_error_codes/error_codes/E0254.md b/src/librustc_error_codes/error_codes/E0254.md new file mode 100644 index 00000000000..44383ed6eab --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0254.md @@ -0,0 +1,36 @@ +Attempt was made to import an item whereas an extern crate with this name has +already been imported. + +Erroneous code example: + +```compile_fail,E0254 +extern crate core; + +mod foo { + pub trait core { + fn do_something(); + } +} + +use foo::core; // error: an extern crate named `core` has already + // been imported in this module + +fn main() {} +``` + +To fix this issue, you have to rename at least one of the two imports. +Example: + +``` +extern crate core as libcore; // ok! + +mod foo { + pub trait core { + fn do_something(); + } +} + +use foo::core; + +fn main() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0255.md b/src/librustc_error_codes/error_codes/E0255.md new file mode 100644 index 00000000000..83f5ec3dda4 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0255.md @@ -0,0 +1,44 @@ +You can't import a value whose name is the same as another value defined in the +module. + +Erroneous code example: + +```compile_fail,E0255 +use bar::foo; // error: an item named `foo` is already in scope + +fn foo() {} + +mod bar { + pub fn foo() {} +} + +fn main() {} +``` + +You can use aliases in order to fix this error. Example: + +``` +use bar::foo as bar_foo; // ok! + +fn foo() {} + +mod bar { + pub fn foo() {} +} + +fn main() {} +``` + +Or you can reference the item with its parent: + +``` +fn foo() {} + +mod bar { + pub fn foo() {} +} + +fn main() { + bar::foo(); // we get the item by referring to its parent +} +``` diff --git a/src/librustc_error_codes/error_codes/E0256.md b/src/librustc_error_codes/error_codes/E0256.md new file mode 100644 index 00000000000..385376cdade --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0256.md @@ -0,0 +1,18 @@ +#### Note: this error code is no longer emitted by the compiler. + +You can't import a type or module when the name of the item being imported is +the same as another type or submodule defined in the module. + +An example of this error: + +```compile_fail +use foo::Bar; // error + +type Bar = u32; + +mod foo { + pub mod Bar { } +} + +fn main() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0259.md b/src/librustc_error_codes/error_codes/E0259.md new file mode 100644 index 00000000000..8d8f93db30f --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0259.md @@ -0,0 +1,23 @@ +The name chosen for an external crate conflicts with another external crate +that has been imported into the current module. + +Erroneous code example: + +```compile_fail,E0259 +extern crate core; +extern crate std as core; + +fn main() {} +``` + +The solution is to choose a different name that doesn't conflict with any +external crate imported into the current module. + +Correct example: + +``` +extern crate core; +extern crate std as other_name; + +fn main() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0260.md b/src/librustc_error_codes/error_codes/E0260.md new file mode 100644 index 00000000000..4a36735ae76 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0260.md @@ -0,0 +1,34 @@ +The name for an item declaration conflicts with an external crate's name. + +Erroneous code example: + +```compile_fail,E0260 +extern crate core; + +struct core; + +fn main() {} +``` + +There are two possible solutions: + +Solution #1: Rename the item. + +``` +extern crate core; + +struct xyz; +``` + +Solution #2: Import the crate with a different name. + +``` +extern crate core as xyz; + +struct abc; +``` + +See the Declaration Statements section of the reference for more information +about what constitutes an Item declaration and what does not: + +https://doc.rust-lang.org/reference.html#statements diff --git a/src/librustc_error_codes/error_codes/E0261.md b/src/librustc_error_codes/error_codes/E0261.md new file mode 100644 index 00000000000..21cf8e70452 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0261.md @@ -0,0 +1,53 @@ +When using a lifetime like `'a` in a type, it must be declared before being +used. + +These two examples illustrate the problem: + +```compile_fail,E0261 +// error, use of undeclared lifetime name `'a` +fn foo(x: &'a str) { } + +struct Foo { + // error, use of undeclared lifetime name `'a` + x: &'a str, +} +``` + +These can be fixed by declaring lifetime parameters: + +``` +struct Foo<'a> { + x: &'a str, +} + +fn foo<'a>(x: &'a str) {} +``` + +Impl blocks declare lifetime parameters separately. You need to add lifetime +parameters to an impl block if you're implementing a type that has a lifetime +parameter of its own. +For example: + +```compile_fail,E0261 +struct Foo<'a> { + x: &'a str, +} + +// error, use of undeclared lifetime name `'a` +impl Foo<'a> { + fn foo<'a>(x: &'a str) {} +} +``` + +This is fixed by declaring the impl block like this: + +``` +struct Foo<'a> { + x: &'a str, +} + +// correct +impl<'a> Foo<'a> { + fn foo(x: &'a str) {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0262.md b/src/librustc_error_codes/error_codes/E0262.md new file mode 100644 index 00000000000..2dca6b1bb07 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0262.md @@ -0,0 +1,8 @@ +Declaring certain lifetime names in parameters is disallowed. For example, +because the `'static` lifetime is a special built-in lifetime name denoting +the lifetime of the entire program, this is an error: + +```compile_fail,E0262 +// error, invalid lifetime parameter name `'static` +fn foo<'static>(x: &'static str) { } +``` diff --git a/src/librustc_error_codes/error_codes/E0263.md b/src/librustc_error_codes/error_codes/E0263.md new file mode 100644 index 00000000000..bb4da43b3f5 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0263.md @@ -0,0 +1,7 @@ +A lifetime name cannot be declared more than once in the same scope. For +example: + +```compile_fail,E0263 +// error, lifetime name `'a` declared twice in the same scope +fn foo<'a, 'b, 'a>(x: &'a str, y: &'b str) { } +``` diff --git a/src/librustc_error_codes/error_codes/E0264.md b/src/librustc_error_codes/error_codes/E0264.md new file mode 100644 index 00000000000..e1e7516cec2 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0264.md @@ -0,0 +1,22 @@ +An unknown external lang item was used. Erroneous code example: + +```compile_fail,E0264 +#![feature(lang_items)] + +extern "C" { + #[lang = "cake"] // error: unknown external lang item: `cake` + fn cake(); +} +``` + +A list of available external lang items is available in +`src/librustc/middle/weak_lang_items.rs`. Example: + +``` +#![feature(lang_items)] + +extern "C" { + #[lang = "panic_impl"] // ok! + fn cake(); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0267.md b/src/librustc_error_codes/error_codes/E0267.md new file mode 100644 index 00000000000..066ebee0ffb --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0267.md @@ -0,0 +1,20 @@ +This error indicates the use of a loop keyword (`break` or `continue`) inside a +closure but outside of any loop. Erroneous code example: + +```compile_fail,E0267 +let w = || { break; }; // error: `break` inside of a closure +``` + +`break` and `continue` keywords can be used as normal inside closures as long as +they are also contained within a loop. To halt the execution of a closure you +should instead use a return statement. Example: + +``` +let w = || { + for _ in 0..10 { + break; + } +}; + +w(); +``` diff --git a/src/librustc_error_codes/error_codes/E0268.md b/src/librustc_error_codes/error_codes/E0268.md new file mode 100644 index 00000000000..7f3ac118601 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0268.md @@ -0,0 +1,19 @@ +This error indicates the use of a loop keyword (`break` or `continue`) outside +of a loop. Without a loop to break out of or continue in, no sensible action can +be taken. Erroneous code example: + +```compile_fail,E0268 +fn some_func() { + break; // error: `break` outside of a loop +} +``` + +Please verify that you are using `break` and `continue` only in loops. Example: + +``` +fn some_func() { + for _ in 0..10 { + break; // ok! + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0271.md b/src/librustc_error_codes/error_codes/E0271.md new file mode 100644 index 00000000000..4078598b394 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0271.md @@ -0,0 +1,80 @@ +This is because of a type mismatch between the associated type of some +trait (e.g., `T::Bar`, where `T` implements `trait Quux { type Bar; }`) +and another type `U` that is required to be equal to `T::Bar`, but is not. +Examples follow. + +Here is a basic example: + +```compile_fail,E0271 +trait Trait { type AssociatedType; } + +fn foo<T>(t: T) where T: Trait<AssociatedType=u32> { + println!("in foo"); +} + +impl Trait for i8 { type AssociatedType = &'static str; } + +foo(3_i8); +``` + +Here is that same example again, with some explanatory comments: + +```compile_fail,E0271 +trait Trait { type AssociatedType; } + +fn foo<T>(t: T) where T: Trait<AssociatedType=u32> { +// ~~~~~~~~ ~~~~~~~~~~~~~~~~~~ +// | | +// This says `foo` can | +// only be used with | +// some type that | +// implements `Trait`. | +// | +// This says not only must +// `T` be an impl of `Trait` +// but also that the impl +// must assign the type `u32` +// to the associated type. + println!("in foo"); +} + +impl Trait for i8 { type AssociatedType = &'static str; } +//~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// | | +// `i8` does have | +// implementation | +// of `Trait`... | +// ... but it is an implementation +// that assigns `&'static str` to +// the associated type. + +foo(3_i8); +// Here, we invoke `foo` with an `i8`, which does not satisfy +// the constraint `<i8 as Trait>::AssociatedType=u32`, and +// therefore the type-checker complains with this error code. +``` + +To avoid those issues, you have to make the types match correctly. +So we can fix the previous examples like this: + +``` +// Basic Example: +trait Trait { type AssociatedType; } + +fn foo<T>(t: T) where T: Trait<AssociatedType = &'static str> { + println!("in foo"); +} + +impl Trait for i8 { type AssociatedType = &'static str; } + +foo(3_i8); + +// For-Loop Example: +let vs = vec![1, 2, 3, 4]; +for v in &vs { + match v { + &1 => {} + _ => {} + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0275.md b/src/librustc_error_codes/error_codes/E0275.md new file mode 100644 index 00000000000..836a9a95fa1 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0275.md @@ -0,0 +1,20 @@ +This error occurs when there was a recursive trait requirement that overflowed +before it could be evaluated. Often this means that there is unbounded +recursion in resolving some type bounds. + +For example, in the following code: + +```compile_fail,E0275 +trait Foo {} + +struct Bar<T>(T); + +impl<T> Foo for T where Bar<T>: Foo {} +``` + +To determine if a `T` is `Foo`, we need to check if `Bar<T>` is `Foo`. However, +to do this check, we need to determine that `Bar<Bar<T>>` is `Foo`. To +determine this, we check if `Bar<Bar<Bar<T>>>` is `Foo`, and so on. This is +clearly a recursive requirement that can't be resolved directly. + +Consider changing your trait bounds so that they're less self-referential. diff --git a/src/librustc_error_codes/error_codes/E0276.md b/src/librustc_error_codes/error_codes/E0276.md new file mode 100644 index 00000000000..0e3a613bf9c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0276.md @@ -0,0 +1,19 @@ +This error occurs when a bound in an implementation of a trait does not match +the bounds specified in the original trait. For example: + +```compile_fail,E0276 +trait Foo { + fn foo<T>(x: T); +} + +impl Foo for bool { + fn foo<T>(x: T) where T: Copy {} +} +``` + +Here, all types implementing `Foo` must have a method `foo<T>(x: T)` which can +take any type `T`. However, in the `impl` for `bool`, we have added an extra +bound that `T` is `Copy`, which isn't compatible with the original trait. + +Consider removing the bound from the method or adding the bound to the original +method definition in the trait. diff --git a/src/librustc_error_codes/error_codes/E0277.md b/src/librustc_error_codes/error_codes/E0277.md new file mode 100644 index 00000000000..2034a5b988c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0277.md @@ -0,0 +1,85 @@ +You tried to use a type which doesn't implement some trait in a place which +expected that trait. Erroneous code example: + +```compile_fail,E0277 +// here we declare the Foo trait with a bar method +trait Foo { + fn bar(&self); +} + +// we now declare a function which takes an object implementing the Foo trait +fn some_func<T: Foo>(foo: T) { + foo.bar(); +} + +fn main() { + // we now call the method with the i32 type, which doesn't implement + // the Foo trait + some_func(5i32); // error: the trait bound `i32 : Foo` is not satisfied +} +``` + +In order to fix this error, verify that the type you're using does implement +the trait. Example: + +``` +trait Foo { + fn bar(&self); +} + +fn some_func<T: Foo>(foo: T) { + foo.bar(); // we can now use this method since i32 implements the + // Foo trait +} + +// we implement the trait on the i32 type +impl Foo for i32 { + fn bar(&self) {} +} + +fn main() { + some_func(5i32); // ok! +} +``` + +Or in a generic context, an erroneous code example would look like: + +```compile_fail,E0277 +fn some_func<T>(foo: T) { + println!("{:?}", foo); // error: the trait `core::fmt::Debug` is not + // implemented for the type `T` +} + +fn main() { + // We now call the method with the i32 type, + // which *does* implement the Debug trait. + some_func(5i32); +} +``` + +Note that the error here is in the definition of the generic function: Although +we only call it with a parameter that does implement `Debug`, the compiler +still rejects the function: It must work with all possible input types. In +order to make this example compile, we need to restrict the generic type we're +accepting: + +``` +use std::fmt; + +// Restrict the input type to types that implement Debug. +fn some_func<T: fmt::Debug>(foo: T) { + println!("{:?}", foo); +} + +fn main() { + // Calling the method is still fine, as i32 implements Debug. + some_func(5i32); + + // This would fail to compile now: + // struct WithoutDebug; + // some_func(WithoutDebug); +} +``` + +Rust only looks at the signature of the called function, as such it must +already specify all requirements that will be used for every type parameter. diff --git a/src/librustc_error_codes/error_codes/E0281.md b/src/librustc_error_codes/error_codes/E0281.md new file mode 100644 index 00000000000..1a9796d2790 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0281.md @@ -0,0 +1,20 @@ +#### Note: this error code is no longer emitted by the compiler. + +You tried to supply a type which doesn't implement some trait in a location +which expected that trait. This error typically occurs when working with +`Fn`-based types. Erroneous code example: + +```compile-fail +fn foo<F: Fn(usize)>(x: F) { } + +fn main() { + // type mismatch: ... implements the trait `core::ops::Fn<(String,)>`, + // but the trait `core::ops::Fn<(usize,)>` is required + // [E0281] + foo(|y: String| { }); +} +``` + +The issue in this case is that `foo` is defined as accepting a `Fn` with one +argument of type `String`, but the closure we attempted to pass to it requires +one arguments of type `usize`. diff --git a/src/librustc_error_codes/error_codes/E0282.md b/src/librustc_error_codes/error_codes/E0282.md new file mode 100644 index 00000000000..54a9de0025a --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0282.md @@ -0,0 +1,65 @@ +This error indicates that type inference did not result in one unique possible +type, and extra information is required. In most cases this can be provided +by adding a type annotation. Sometimes you need to specify a generic type +parameter manually. + +A common example is the `collect` method on `Iterator`. It has a generic type +parameter with a `FromIterator` bound, which for a `char` iterator is +implemented by `Vec` and `String` among others. Consider the following snippet +that reverses the characters of a string: + +```compile_fail,E0282 +let x = "hello".chars().rev().collect(); +``` + +In this case, the compiler cannot infer what the type of `x` should be: +`Vec<char>` and `String` are both suitable candidates. To specify which type to +use, you can use a type annotation on `x`: + +``` +let x: Vec<char> = "hello".chars().rev().collect(); +``` + +It is not necessary to annotate the full type. Once the ambiguity is resolved, +the compiler can infer the rest: + +``` +let x: Vec<_> = "hello".chars().rev().collect(); +``` + +Another way to provide the compiler with enough information, is to specify the +generic type parameter: + +``` +let x = "hello".chars().rev().collect::<Vec<char>>(); +``` + +Again, you need not specify the full type if the compiler can infer it: + +``` +let x = "hello".chars().rev().collect::<Vec<_>>(); +``` + +Apart from a method or function with a generic type parameter, this error can +occur when a type parameter of a struct or trait cannot be inferred. In that +case it is not always possible to use a type annotation, because all candidates +have the same return type. For instance: + +```compile_fail,E0282 +struct Foo<T> { + num: T, +} + +impl<T> Foo<T> { + fn bar() -> i32 { + 0 + } + + fn baz() { + let number = Foo::bar(); + } +} +``` + +This will fail because the compiler does not know which instance of `Foo` to +call `bar` on. Change `Foo::bar()` to `Foo::<T>::bar()` to resolve the error. diff --git a/src/librustc_error_codes/error_codes/E0283.md b/src/librustc_error_codes/error_codes/E0283.md new file mode 100644 index 00000000000..075f8b2e3bb --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0283.md @@ -0,0 +1,49 @@ +This error occurs when the compiler doesn't have enough information +to unambiguously choose an implementation. + +For example: + +```compile_fail,E0283 +trait Generator { + fn create() -> u32; +} + +struct Impl; + +impl Generator for Impl { + fn create() -> u32 { 1 } +} + +struct AnotherImpl; + +impl Generator for AnotherImpl { + fn create() -> u32 { 2 } +} + +fn main() { + let cont: u32 = Generator::create(); + // error, impossible to choose one of Generator trait implementation + // Should it be Impl or AnotherImpl, maybe something else? +} +``` + +To resolve this error use the concrete type: + +``` +trait Generator { + fn create() -> u32; +} + +struct AnotherImpl; + +impl Generator for AnotherImpl { + fn create() -> u32 { 2 } +} + +fn main() { + let gen1 = AnotherImpl::create(); + + // if there are multiple methods with same name (different traits) + let gen2 = <AnotherImpl as Generator>::create(); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0284.md b/src/librustc_error_codes/error_codes/E0284.md new file mode 100644 index 00000000000..a1ffa2bda00 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0284.md @@ -0,0 +1,42 @@ +This error occurs when the compiler is unable to unambiguously infer the +return type of a function or method which is generic on return type, such +as the `collect` method for `Iterator`s. + +For example: + +```compile_fail,E0284 +fn foo() -> Result<bool, ()> { + let results = [Ok(true), Ok(false), Err(())].iter().cloned(); + let v: Vec<bool> = results.collect()?; + // Do things with v... + Ok(true) +} +``` + +Here we have an iterator `results` over `Result<bool, ()>`. +Hence, `results.collect()` can return any type implementing +`FromIterator<Result<bool, ()>>`. On the other hand, the +`?` operator can accept any type implementing `Try`. + +The author of this code probably wants `collect()` to return a +`Result<Vec<bool>, ()>`, but the compiler can't be sure +that there isn't another type `T` implementing both `Try` and +`FromIterator<Result<bool, ()>>` in scope such that +`T::Ok == Vec<bool>`. Hence, this code is ambiguous and an error +is returned. + +To resolve this error, use a concrete type for the intermediate expression: + +``` +fn foo() -> Result<bool, ()> { + let results = [Ok(true), Ok(false), Err(())].iter().cloned(); + let v = { + let temp: Result<Vec<bool>, ()> = results.collect(); + temp? + }; + // Do things with v... + Ok(true) +} +``` + +Note that the type of `v` can now be inferred from the type of `temp`. diff --git a/src/librustc_error_codes/error_codes/E0297.md b/src/librustc_error_codes/error_codes/E0297.md new file mode 100644 index 00000000000..66c31376d8b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0297.md @@ -0,0 +1,40 @@ +#### Note: this error code is no longer emitted by the compiler. + +Patterns used to bind names must be irrefutable. That is, they must guarantee +that a name will be extracted in all cases. Instead of pattern matching the +loop variable, consider using a `match` or `if let` inside the loop body. For +instance: + +```compile_fail,E0005 +let xs : Vec<Option<i32>> = vec![Some(1), None]; + +// This fails because `None` is not covered. +for Some(x) in xs { + // ... +} +``` + +Match inside the loop instead: + +``` +let xs : Vec<Option<i32>> = vec![Some(1), None]; + +for item in xs { + match item { + Some(x) => {}, + None => {}, + } +} +``` + +Or use `if let`: + +``` +let xs : Vec<Option<i32>> = vec![Some(1), None]; + +for item in xs { + if let Some(x) = item { + // ... + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0301.md b/src/librustc_error_codes/error_codes/E0301.md new file mode 100644 index 00000000000..485e19fbb8d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0301.md @@ -0,0 +1,17 @@ +#### Note: this error code is no longer emitted by the compiler. + +Mutable borrows are not allowed in pattern guards, because matching cannot have +side effects. Side effects could alter the matched object or the environment +on which the match depends in such a way, that the match would not be +exhaustive. For instance, the following would not match any arm if mutable +borrows were allowed: + +```compile_fail,E0596 +match Some(()) { + None => { }, + option if option.take().is_none() => { + /* impossible, option is `Some` */ + }, + Some(_) => { } // When the previous match failed, the option became `None`. +} +``` diff --git a/src/librustc_error_codes/error_codes/E0302.md b/src/librustc_error_codes/error_codes/E0302.md new file mode 100644 index 00000000000..e6ac9d590c8 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0302.md @@ -0,0 +1,15 @@ +#### Note: this error code is no longer emitted by the compiler. + +Assignments are not allowed in pattern guards, because matching cannot have +side effects. Side effects could alter the matched object or the environment +on which the match depends in such a way, that the match would not be +exhaustive. For instance, the following would not match any arm if assignments +were allowed: + +```compile_fail,E0594 +match Some(()) { + None => { }, + option if { option = None; false } => { }, + Some(_) => { } // When the previous match failed, the option became `None`. +} +``` diff --git a/src/librustc_error_codes/error_codes/E0303.md b/src/librustc_error_codes/error_codes/E0303.md new file mode 100644 index 00000000000..20a6c078f4f --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0303.md @@ -0,0 +1,28 @@ +In certain cases it is possible for sub-bindings to violate memory safety. +Updates to the borrow checker in a future version of Rust may remove this +restriction, but for now patterns must be rewritten without sub-bindings. + +Before: + +```compile_fail,E0303 +match Some("hi".to_string()) { + ref op_string_ref @ Some(s) => {}, + None => {}, +} +``` + +After: + +``` +match Some("hi".to_string()) { + Some(ref s) => { + let op_string_ref = &Some(s); + // ... + }, + None => {}, +} +``` + +The `op_string_ref` binding has type `&Option<&String>` in both cases. + +See also https://github.com/rust-lang/rust/issues/14587 diff --git a/src/librustc_error_codes/error_codes/E0307.md b/src/librustc_error_codes/error_codes/E0307.md new file mode 100644 index 00000000000..c382f406e4b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0307.md @@ -0,0 +1,78 @@ +This error indicates that the `self` parameter in a method has an invalid +"reciever type". + +Methods take a special first parameter, of which there are three variants: +`self`, `&self`, and `&mut self`. These are syntactic sugar for +`self: Self`, `self: &Self`, and `self: &mut Self` respectively. + +``` +# struct Foo; +trait Trait { + fn foo(&self); +// ^^^^^ `self` here is a reference to the receiver object +} + +impl Trait for Foo { + fn foo(&self) {} +// ^^^^^ the receiver type is `&Foo` +} +``` + +The type `Self` acts as an alias to the type of the current trait +implementer, or "receiver type". Besides the already mentioned `Self`, +`&Self` and `&mut Self` valid receiver types, the following are also valid: +`self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, and `self: Pin<P>` +(where P is one of the previous types except `Self`). Note that `Self` can +also be the underlying implementing type, like `Foo` in the following +example: + +``` +# struct Foo; +# trait Trait { +# fn foo(&self); +# } +impl Trait for Foo { + fn foo(self: &Foo) {} +} +``` + +E0307 will be emitted by the compiler when using an invalid reciver type, +like in the following example: + +```compile_fail,E0307 +# struct Foo; +# struct Bar; +# trait Trait { +# fn foo(&self); +# } +impl Trait for Foo { + fn foo(self: &Bar) {} +} +``` + +The nightly feature [Arbintrary self types][AST] extends the accepted +set of receiver types to also include any type that can dereference to +`Self`: + +``` +#![feature(arbitrary_self_types)] + +struct Foo; +struct Bar; + +// Because you can dereference `Bar` into `Foo`... +impl std::ops::Deref for Bar { + type Target = Foo; + + fn deref(&self) -> &Foo { + &Foo + } +} + +impl Foo { + fn foo(self: Bar) {} +// ^^^^^^^^^ ...it can be used as the receiver type +} +``` + +[AST]: https://doc.rust-lang.org/unstable-book/language-features/arbitrary-self-types.html diff --git a/src/librustc_error_codes/error_codes/E0308.md b/src/librustc_error_codes/error_codes/E0308.md new file mode 100644 index 00000000000..a907ca27297 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0308.md @@ -0,0 +1,17 @@ +This error occurs when the compiler was unable to infer the concrete type of a +variable. It can occur for several cases, the most common of which is a +mismatch in the expected type that the compiler inferred for a variable's +initializing expression, and the actual type explicitly assigned to the +variable. + +For example: + +```compile_fail,E0308 +let x: i32 = "I am not a number!"; +// ~~~ ~~~~~~~~~~~~~~~~~~~~ +// | | +// | initializing expression; +// | compiler infers type `&str` +// | +// type `i32` assigned to variable `x` +``` diff --git a/src/librustc_error_codes/error_codes/E0309.md b/src/librustc_error_codes/error_codes/E0309.md new file mode 100644 index 00000000000..73ce7407476 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0309.md @@ -0,0 +1,50 @@ +The type definition contains some field whose type +requires an outlives annotation. Outlives annotations +(e.g., `T: 'a`) are used to guarantee that all the data in T is valid +for at least the lifetime `'a`. This scenario most commonly +arises when the type contains an associated type reference +like `<T as SomeTrait<'a>>::Output`, as shown in this example: + +```compile_fail,E0309 +// This won't compile because the applicable impl of +// `SomeTrait` (below) requires that `T: 'a`, but the struct does +// not have a matching where-clause. +struct Foo<'a, T> { + foo: <T as SomeTrait<'a>>::Output, +} + +trait SomeTrait<'a> { + type Output; +} + +impl<'a, T> SomeTrait<'a> for T +where + T: 'a, +{ + type Output = u32; +} +``` + +Here, the where clause `T: 'a` that appears on the impl is not known to be +satisfied on the struct. To make this example compile, you have to add +a where-clause like `T: 'a` to the struct definition: + +``` +struct Foo<'a, T> +where + T: 'a, +{ + foo: <T as SomeTrait<'a>>::Output +} + +trait SomeTrait<'a> { + type Output; +} + +impl<'a, T> SomeTrait<'a> for T +where + T: 'a, +{ + type Output = u32; +} +``` diff --git a/src/librustc_error_codes/error_codes/E0310.md b/src/librustc_error_codes/error_codes/E0310.md new file mode 100644 index 00000000000..be87ccb114a --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0310.md @@ -0,0 +1,20 @@ +Types in type definitions have lifetimes associated with them that represent +how long the data stored within them is guaranteed to be live. This lifetime +must be as long as the data needs to be alive, and missing the constraint that +denotes this will cause this error. + +```compile_fail,E0310 +// This won't compile because T is not constrained to the static lifetime +// the reference needs +struct Foo<T> { + foo: &'static T +} +``` + +This will compile, because it has the constraint on the type parameter: + +``` +struct Foo<T: 'static> { + foo: &'static T +} +``` diff --git a/src/librustc_error_codes/error_codes/E0312.md b/src/librustc_error_codes/error_codes/E0312.md new file mode 100644 index 00000000000..cb090d01382 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0312.md @@ -0,0 +1,30 @@ +Reference's lifetime of borrowed content doesn't match the expected lifetime. + +Erroneous code example: + +```compile_fail,E0312 +pub fn opt_str<'a>(maybestr: &'a Option<String>) -> &'static str { + if maybestr.is_none() { + "(none)" + } else { + let s: &'a str = maybestr.as_ref().unwrap(); + s // Invalid lifetime! + } +} +``` + +To fix this error, either lessen the expected lifetime or find a way to not have +to use this reference outside of its current scope (by running the code directly +in the same block for example?): + +``` +// In this case, we can fix the issue by switching from "static" lifetime to 'a +pub fn opt_str<'a>(maybestr: &'a Option<String>) -> &'a str { + if maybestr.is_none() { + "(none)" + } else { + let s: &'a str = maybestr.as_ref().unwrap(); + s // Ok! + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0317.md b/src/librustc_error_codes/error_codes/E0317.md new file mode 100644 index 00000000000..e31a2b56be3 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0317.md @@ -0,0 +1,14 @@ +This error occurs when an `if` expression without an `else` block is used in a +context where a type other than `()` is expected, for example a `let` +expression: + +```compile_fail,E0317 +fn main() { + let x = 5; + let a = if x == 5 { 1 }; +} +``` + +An `if` expression without an `else` block has the type `()`, so this is a type +error. To resolve it, add an `else` block having the same type as the `if` +block. diff --git a/src/librustc_error_codes/error_codes/E0321.md b/src/librustc_error_codes/error_codes/E0321.md new file mode 100644 index 00000000000..49cec94430b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0321.md @@ -0,0 +1,19 @@ +A cross-crate opt-out trait was implemented on something which wasn't a struct +or enum type. Erroneous code example: + +```compile_fail,E0321 +#![feature(optin_builtin_traits)] + +struct Foo; + +impl !Sync for Foo {} + +unsafe impl Send for &'static Foo {} +// error: cross-crate traits with a default impl, like `core::marker::Send`, +// can only be implemented for a struct/enum type, not +// `&'static Foo` +``` + +Only structs and enums are permitted to impl Send, Sync, and other opt-out +trait, and the struct or enum must be local to the current crate. So, for +example, `unsafe impl Send for Rc<Foo>` is not allowed. diff --git a/src/librustc_error_codes/error_codes/E0322.md b/src/librustc_error_codes/error_codes/E0322.md new file mode 100644 index 00000000000..d2ee426763e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0322.md @@ -0,0 +1,4 @@ +The `Sized` trait is a special trait built-in to the compiler for types with a +constant size known at compile-time. This trait is automatically implemented +for types as needed by the compiler, and it is currently disallowed to +explicitly implement it for a type. diff --git a/src/librustc_error_codes/error_codes/E0323.md b/src/librustc_error_codes/error_codes/E0323.md new file mode 100644 index 00000000000..6d34c35f9cb --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0323.md @@ -0,0 +1,45 @@ +An associated const was implemented when another trait item was expected. +Erroneous code example: + +```compile_fail,E0323 +trait Foo { + type N; +} + +struct Bar; + +impl Foo for Bar { + const N : u32 = 0; + // error: item `N` is an associated const, which doesn't match its + // trait `<Bar as Foo>` +} +``` + +Please verify that the associated const wasn't misspelled and the correct trait +was implemented. Example: + +``` +struct Bar; + +trait Foo { + type N; +} + +impl Foo for Bar { + type N = u32; // ok! +} +``` + +Or: + +``` +struct Bar; + +trait Foo { + const N : u32; +} + +impl Foo for Bar { + const N : u32 = 0; // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0324.md b/src/librustc_error_codes/error_codes/E0324.md new file mode 100644 index 00000000000..b8c9e596990 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0324.md @@ -0,0 +1,37 @@ +A method was implemented when another trait item was expected. Erroneous +code example: + +```compile_fail,E0324 +struct Bar; + +trait Foo { + const N : u32; + + fn M(); +} + +impl Foo for Bar { + fn N() {} + // error: item `N` is an associated method, which doesn't match its + // trait `<Bar as Foo>` +} +``` + +To fix this error, please verify that the method name wasn't misspelled and +verify that you are indeed implementing the correct trait items. Example: + +``` +struct Bar; + +trait Foo { + const N : u32; + + fn M(); +} + +impl Foo for Bar { + const N : u32 = 0; + + fn M() {} // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0325.md b/src/librustc_error_codes/error_codes/E0325.md new file mode 100644 index 00000000000..f685b92cbf0 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0325.md @@ -0,0 +1,45 @@ +An associated type was implemented when another trait item was expected. +Erroneous code example: + +```compile_fail,E0325 +struct Bar; + +trait Foo { + const N : u32; +} + +impl Foo for Bar { + type N = u32; + // error: item `N` is an associated type, which doesn't match its + // trait `<Bar as Foo>` +} +``` + +Please verify that the associated type name wasn't misspelled and your +implementation corresponds to the trait definition. Example: + +``` +struct Bar; + +trait Foo { + type N; +} + +impl Foo for Bar { + type N = u32; // ok! +} +``` + +Or: + +``` +struct Bar; + +trait Foo { + const N : u32; +} + +impl Foo for Bar { + const N : u32 = 0; // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0326.md b/src/librustc_error_codes/error_codes/E0326.md new file mode 100644 index 00000000000..0702d00c2de --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0326.md @@ -0,0 +1,16 @@ +The types of any associated constants in a trait implementation must match the +types in the trait definition. This error indicates that there was a mismatch. + +Here's an example of this error: + +```compile_fail,E0326 +trait Foo { + const BAR: bool; +} + +struct Bar; + +impl Foo for Bar { + const BAR: u32 = 5; // error, expected bool, found u32 +} +``` diff --git a/src/librustc_error_codes/error_codes/E0328.md b/src/librustc_error_codes/error_codes/E0328.md new file mode 100644 index 00000000000..83909235455 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0328.md @@ -0,0 +1,34 @@ +The Unsize trait should not be implemented directly. All implementations of +Unsize are provided automatically by the compiler. + +Erroneous code example: + +```compile_fail,E0328 +#![feature(unsize)] + +use std::marker::Unsize; + +pub struct MyType; + +impl<T> Unsize<T> for MyType {} +``` + +If you are defining your own smart pointer type and would like to enable +conversion from a sized to an unsized type with the +[DST coercion system][RFC 982], use [`CoerceUnsized`] instead. + +``` +#![feature(coerce_unsized)] + +use std::ops::CoerceUnsized; + +pub struct MyType<T: ?Sized> { + field_with_unsized_type: T, +} + +impl<T, U> CoerceUnsized<MyType<U>> for MyType<T> + where T: CoerceUnsized<U> {} +``` + +[RFC 982]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md +[`CoerceUnsized`]: https://doc.rust-lang.org/std/ops/trait.CoerceUnsized.html diff --git a/src/librustc_error_codes/error_codes/E0329.md b/src/librustc_error_codes/error_codes/E0329.md new file mode 100644 index 00000000000..37d84a1a89b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0329.md @@ -0,0 +1,40 @@ +#### Note: this error code is no longer emitted by the compiler. + +An attempt was made to access an associated constant through either a generic +type parameter or `Self`. This is not supported yet. An example causing this +error is shown below: + +``` +trait Foo { + const BAR: f64; +} + +struct MyStruct; + +impl Foo for MyStruct { + const BAR: f64 = 0f64; +} + +fn get_bar_bad<F: Foo>(t: F) -> f64 { + F::BAR +} +``` + +Currently, the value of `BAR` for a particular type can only be accessed +through a concrete type, as shown below: + +``` +trait Foo { + const BAR: f64; +} + +struct MyStruct; + +impl Foo for MyStruct { + const BAR: f64 = 0f64; +} + +fn get_bar_good() -> f64 { + <MyStruct as Foo>::BAR +} +``` diff --git a/src/librustc_error_codes/error_codes/E0364.md b/src/librustc_error_codes/error_codes/E0364.md new file mode 100644 index 00000000000..0cca8f58b17 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0364.md @@ -0,0 +1,32 @@ +Private items cannot be publicly re-exported. This error indicates that you +attempted to `pub use` a type or value that was not itself public. + +Erroneous code example: + +```compile_fail +mod foo { + const X: u32 = 1; +} + +pub use foo::X; + +fn main() {} +``` + +The solution to this problem is to ensure that the items that you are +re-exporting are themselves marked with `pub`: + +``` +mod foo { + pub const X: u32 = 1; +} + +pub use foo::X; + +fn main() {} +``` + +See the 'Use Declarations' section of the reference for more information on +this topic: + +https://doc.rust-lang.org/reference.html#use-declarations diff --git a/src/librustc_error_codes/error_codes/E0365.md b/src/librustc_error_codes/error_codes/E0365.md new file mode 100644 index 00000000000..8f90d949e30 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0365.md @@ -0,0 +1,32 @@ +Private modules cannot be publicly re-exported. This error indicates that you +attempted to `pub use` a module that was not itself public. + +Erroneous code example: + +```compile_fail,E0365 +mod foo { + pub const X: u32 = 1; +} + +pub use foo as foo2; + +fn main() {} +``` + +The solution to this problem is to ensure that the module that you are +re-exporting is itself marked with `pub`: + +``` +pub mod foo { + pub const X: u32 = 1; +} + +pub use foo as foo2; + +fn main() {} +``` + +See the 'Use Declarations' section of the reference for more information +on this topic: + +https://doc.rust-lang.org/reference.html#use-declarations diff --git a/src/librustc_error_codes/error_codes/E0366.md b/src/librustc_error_codes/error_codes/E0366.md new file mode 100644 index 00000000000..e6f8e61893b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0366.md @@ -0,0 +1,30 @@ +An attempt was made to implement `Drop` on a concrete specialization of a +generic type. An example is shown below: + +```compile_fail,E0366 +struct Foo<T> { + t: T +} + +impl Drop for Foo<u32> { + fn drop(&mut self) {} +} +``` + +This code is not legal: it is not possible to specialize `Drop` to a subset of +implementations of a generic type. One workaround for this is to wrap the +generic type, as shown below: + +``` +struct Foo<T> { + t: T +} + +struct Bar { + t: Foo<u32> +} + +impl Drop for Bar { + fn drop(&mut self) {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0367.md b/src/librustc_error_codes/error_codes/E0367.md new file mode 100644 index 00000000000..7d661b2f033 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0367.md @@ -0,0 +1,35 @@ +An attempt was made to implement `Drop` on a specialization of a generic type. +An example is shown below: + +```compile_fail,E0367 +trait Foo{} + +struct MyStruct<T> { + t: T +} + +impl<T: Foo> Drop for MyStruct<T> { + fn drop(&mut self) {} +} +``` + +This code is not legal: it is not possible to specialize `Drop` to a subset of +implementations of a generic type. In order for this code to work, `MyStruct` +must also require that `T` implements `Foo`. Alternatively, another option is +to wrap the generic type in another that specializes appropriately: + +``` +trait Foo{} + +struct MyStruct<T> { + t: T +} + +struct MyStructWrapper<T: Foo> { + t: MyStruct<T> +} + +impl <T: Foo> Drop for MyStructWrapper<T> { + fn drop(&mut self) {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0368.md b/src/librustc_error_codes/error_codes/E0368.md new file mode 100644 index 00000000000..0bb283258c4 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0368.md @@ -0,0 +1,47 @@ +This error indicates that a binary assignment operator like `+=` or `^=` was +applied to a type that doesn't support it. For example: + +```compile_fail,E0368 +let mut x = 12f32; // error: binary operation `<<` cannot be applied to + // type `f32` + +x <<= 2; +``` + +To fix this error, please check that this type implements this binary +operation. Example: + +``` +let mut x = 12u32; // the `u32` type does implement the `ShlAssign` trait + +x <<= 2; // ok! +``` + +It is also possible to overload most operators for your own type by +implementing the `[OP]Assign` traits from `std::ops`. + +Another problem you might be facing is this: suppose you've overloaded the `+` +operator for some type `Foo` by implementing the `std::ops::Add` trait for +`Foo`, but you find that using `+=` does not work, as in this example: + +```compile_fail,E0368 +use std::ops::Add; + +struct Foo(u32); + +impl Add for Foo { + type Output = Foo; + + fn add(self, rhs: Foo) -> Foo { + Foo(self.0 + rhs.0) + } +} + +fn main() { + let mut x: Foo = Foo(5); + x += Foo(7); // error, `+= cannot be applied to the type `Foo` +} +``` + +This is because `AddAssign` is not automatically implemented, so you need to +manually implement it for your type. diff --git a/src/librustc_error_codes/error_codes/E0369.md b/src/librustc_error_codes/error_codes/E0369.md new file mode 100644 index 00000000000..08db342428c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0369.md @@ -0,0 +1,29 @@ +A binary operation was attempted on a type which doesn't support it. +Erroneous code example: + +```compile_fail,E0369 +let x = 12f32; // error: binary operation `<<` cannot be applied to + // type `f32` + +x << 2; +``` + +To fix this error, please check that this type implements this binary +operation. Example: + +``` +let x = 12u32; // the `u32` type does implement it: + // https://doc.rust-lang.org/stable/std/ops/trait.Shl.html + +x << 2; // ok! +``` + +It is also possible to overload most operators for your own type by +implementing traits from `std::ops`. + +String concatenation appends the string on the right to the string on the +left and may require reallocation. This requires ownership of the string +on the left. If something should be added to a string literal, move the +literal to the heap by allocating it with `to_owned()` like in +`"Your text".to_owned()`. + diff --git a/src/librustc_error_codes/error_codes/E0370.md b/src/librustc_error_codes/error_codes/E0370.md new file mode 100644 index 00000000000..a3d280fc6dc --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0370.md @@ -0,0 +1,33 @@ +The maximum value of an enum was reached, so it cannot be automatically +set in the next enum value. Erroneous code example: + +```compile_fail,E0370 +#[repr(i64)] +enum Foo { + X = 0x7fffffffffffffff, + Y, // error: enum discriminant overflowed on value after + // 9223372036854775807: i64; set explicitly via + // Y = -9223372036854775808 if that is desired outcome +} +``` + +To fix this, please set manually the next enum value or put the enum variant +with the maximum value at the end of the enum. Examples: + +``` +#[repr(i64)] +enum Foo { + X = 0x7fffffffffffffff, + Y = 0, // ok! +} +``` + +Or: + +``` +#[repr(i64)] +enum Foo { + Y = 0, // ok! + X = 0x7fffffffffffffff, +} +``` diff --git a/src/librustc_error_codes/error_codes/E0371.md b/src/librustc_error_codes/error_codes/E0371.md new file mode 100644 index 00000000000..9363cddb1dd --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0371.md @@ -0,0 +1,17 @@ +When `Trait2` is a subtrait of `Trait1` (for example, when `Trait2` has a +definition like `trait Trait2: Trait1 { ... }`), it is not allowed to implement +`Trait1` for `Trait2`. This is because `Trait2` already implements `Trait1` by +definition, so it is not useful to do this. + +Example: + +```compile_fail,E0371 +trait Foo { fn foo(&self) { } } +trait Bar: Foo { } +trait Baz: Bar { } + +impl Bar for Baz { } // error, `Baz` implements `Bar` by definition +impl Foo for Baz { } // error, `Baz` implements `Bar` which implements `Foo` +impl Baz for Baz { } // error, `Baz` (trivially) implements `Baz` +impl Baz for Bar { } // Note: This is OK +``` diff --git a/src/librustc_error_codes/error_codes/E0373.md b/src/librustc_error_codes/error_codes/E0373.md new file mode 100644 index 00000000000..47e3a48f031 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0373.md @@ -0,0 +1,48 @@ +This error occurs when an attempt is made to use data captured by a closure, +when that data may no longer exist. It's most commonly seen when attempting to +return a closure: + +```compile_fail,E0373 +fn foo() -> Box<Fn(u32) -> u32> { + let x = 0u32; + Box::new(|y| x + y) +} +``` + +Notice that `x` is stack-allocated by `foo()`. By default, Rust captures +closed-over data by reference. This means that once `foo()` returns, `x` no +longer exists. An attempt to access `x` within the closure would thus be +unsafe. + +Another situation where this might be encountered is when spawning threads: + +```compile_fail,E0373 +fn foo() { + let x = 0u32; + let y = 1u32; + + let thr = std::thread::spawn(|| { + x + y + }); +} +``` + +Since our new thread runs in parallel, the stack frame containing `x` and `y` +may well have disappeared by the time we try to use them. Even if we call +`thr.join()` within foo (which blocks until `thr` has completed, ensuring the +stack frame won't disappear), we will not succeed: the compiler cannot prove +that this behaviour is safe, and so won't let us do it. + +The solution to this problem is usually to switch to using a `move` closure. +This approach moves (or copies, where possible) data into the closure, rather +than taking references to it. For example: + +``` +fn foo() -> Box<Fn(u32) -> u32> { + let x = 0u32; + Box::new(move |y| x + y) +} +``` + +Now that the closure has its own copy of the data, there's no need to worry +about safety. diff --git a/src/librustc_error_codes/error_codes/E0374.md b/src/librustc_error_codes/error_codes/E0374.md new file mode 100644 index 00000000000..0e1a4bf8099 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0374.md @@ -0,0 +1,55 @@ +A struct without a field containing an unsized type cannot implement +`CoerceUnsized`. An [unsized type][1] is any type that the compiler +doesn't know the length or alignment of at compile time. Any struct +containing an unsized type is also unsized. + +[1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait + +Example of erroneous code: + +```compile_fail,E0374 +#![feature(coerce_unsized)] +use std::ops::CoerceUnsized; + +struct Foo<T: ?Sized> { + a: i32, +} + +// error: Struct `Foo` has no unsized fields that need `CoerceUnsized`. +impl<T, U> CoerceUnsized<Foo<U>> for Foo<T> + where T: CoerceUnsized<U> {} +``` + +`CoerceUnsized` is used to coerce one struct containing an unsized type +into another struct containing a different unsized type. If the struct +doesn't have any fields of unsized types then you don't need explicit +coercion to get the types you want. To fix this you can either +not try to implement `CoerceUnsized` or you can add a field that is +unsized to the struct. + +Example: + +``` +#![feature(coerce_unsized)] +use std::ops::CoerceUnsized; + +// We don't need to impl `CoerceUnsized` here. +struct Foo { + a: i32, +} + +// We add the unsized type field to the struct. +struct Bar<T: ?Sized> { + a: i32, + b: T, +} + +// The struct has an unsized field so we can implement +// `CoerceUnsized` for it. +impl<T, U> CoerceUnsized<Bar<U>> for Bar<T> + where T: CoerceUnsized<U> {} +``` + +Note that `CoerceUnsized` is mainly used by smart pointers like `Box`, `Rc` +and `Arc` to be able to mark that they can coerce unsized types that they +are pointing at. diff --git a/src/librustc_error_codes/error_codes/E0375.md b/src/librustc_error_codes/error_codes/E0375.md new file mode 100644 index 00000000000..31fcd85cb07 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0375.md @@ -0,0 +1,52 @@ +A struct with more than one field containing an unsized type cannot implement +`CoerceUnsized`. This only occurs when you are trying to coerce one of the +types in your struct to another type in the struct. In this case we try to +impl `CoerceUnsized` from `T` to `U` which are both types that the struct +takes. An [unsized type][1] is any type that the compiler doesn't know the +length or alignment of at compile time. Any struct containing an unsized type +is also unsized. + +Example of erroneous code: + +```compile_fail,E0375 +#![feature(coerce_unsized)] +use std::ops::CoerceUnsized; + +struct Foo<T: ?Sized, U: ?Sized> { + a: i32, + b: T, + c: U, +} + +// error: Struct `Foo` has more than one unsized field. +impl<T, U> CoerceUnsized<Foo<U, T>> for Foo<T, U> {} +``` + +`CoerceUnsized` only allows for coercion from a structure with a single +unsized type field to another struct with a single unsized type field. +In fact Rust only allows for a struct to have one unsized type in a struct +and that unsized type must be the last field in the struct. So having two +unsized types in a single struct is not allowed by the compiler. To fix this +use only one field containing an unsized type in the struct and then use +multiple structs to manage each unsized type field you need. + +Example: + +``` +#![feature(coerce_unsized)] +use std::ops::CoerceUnsized; + +struct Foo<T: ?Sized> { + a: i32, + b: T, +} + +impl <T, U> CoerceUnsized<Foo<U>> for Foo<T> + where T: CoerceUnsized<U> {} + +fn coerce_foo<T: CoerceUnsized<U>, U>(t: T) -> Foo<U> { + Foo { a: 12i32, b: t } // we use coercion to get the `Foo<U>` type we need +} +``` + +[1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait diff --git a/src/librustc_error_codes/error_codes/E0376.md b/src/librustc_error_codes/error_codes/E0376.md new file mode 100644 index 00000000000..b028aab4583 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0376.md @@ -0,0 +1,45 @@ +The type you are trying to impl `CoerceUnsized` for is not a struct. +`CoerceUnsized` can only be implemented for a struct. Unsized types are +already able to be coerced without an implementation of `CoerceUnsized` +whereas a struct containing an unsized type needs to know the unsized type +field it's containing is able to be coerced. An [unsized type][1] +is any type that the compiler doesn't know the length or alignment of at +compile time. Any struct containing an unsized type is also unsized. + +[1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait + +Example of erroneous code: + +```compile_fail,E0376 +#![feature(coerce_unsized)] +use std::ops::CoerceUnsized; + +struct Foo<T: ?Sized> { + a: T, +} + +// error: The type `U` is not a struct +impl<T, U> CoerceUnsized<U> for Foo<T> {} +``` + +The `CoerceUnsized` trait takes a struct type. Make sure the type you are +providing to `CoerceUnsized` is a struct with only the last field containing an +unsized type. + +Example: + +``` +#![feature(coerce_unsized)] +use std::ops::CoerceUnsized; + +struct Foo<T> { + a: T, +} + +// The `Foo<U>` is a struct so `CoerceUnsized` can be implemented +impl<T, U> CoerceUnsized<Foo<U>> for Foo<T> where T: CoerceUnsized<U> {} +``` + +Note that in Rust, structs can only contain an unsized type if the field +containing the unsized type is the last and only unsized type field in the +struct. diff --git a/src/librustc_error_codes/error_codes/E0378.md b/src/librustc_error_codes/error_codes/E0378.md new file mode 100644 index 00000000000..311483c8900 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0378.md @@ -0,0 +1,57 @@ +The `DispatchFromDyn` trait currently can only be implemented for +builtin pointer types and structs that are newtype wrappers around them +— that is, the struct must have only one field (except for`PhantomData`), +and that field must itself implement `DispatchFromDyn`. + +Examples: + +``` +#![feature(dispatch_from_dyn, unsize)] +use std::{ + marker::Unsize, + ops::DispatchFromDyn, +}; + +struct Ptr<T: ?Sized>(*const T); + +impl<T: ?Sized, U: ?Sized> DispatchFromDyn<Ptr<U>> for Ptr<T> +where + T: Unsize<U>, +{} +``` + +``` +#![feature(dispatch_from_dyn)] +use std::{ + ops::DispatchFromDyn, + marker::PhantomData, +}; + +struct Wrapper<T> { + ptr: T, + _phantom: PhantomData<()>, +} + +impl<T, U> DispatchFromDyn<Wrapper<U>> for Wrapper<T> +where + T: DispatchFromDyn<U>, +{} +``` + +Example of illegal `DispatchFromDyn` implementation +(illegal because of extra field) + +```compile-fail,E0378 +#![feature(dispatch_from_dyn)] +use std::ops::DispatchFromDyn; + +struct WrapperExtraField<T> { + ptr: T, + extra_stuff: i32, +} + +impl<T, U> DispatchFromDyn<WrapperExtraField<U>> for WrapperExtraField<T> +where + T: DispatchFromDyn<U>, +{} +``` diff --git a/src/librustc_error_codes/error_codes/E0379.md b/src/librustc_error_codes/error_codes/E0379.md new file mode 100644 index 00000000000..3503da6ac2f --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0379.md @@ -0,0 +1,4 @@ +Trait methods cannot be declared `const` by design. For more information, see +[RFC 911]. + +[RFC 911]: https://github.com/rust-lang/rfcs/pull/911 diff --git a/src/librustc_error_codes/error_codes/E0380.md b/src/librustc_error_codes/error_codes/E0380.md new file mode 100644 index 00000000000..fe5de569339 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0380.md @@ -0,0 +1,4 @@ +Auto traits cannot have methods or associated items. +For more information see the [opt-in builtin traits RFC][RFC 19]. + +[RFC 19]: https://github.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md diff --git a/src/librustc_error_codes/error_codes/E0381.md b/src/librustc_error_codes/error_codes/E0381.md new file mode 100644 index 00000000000..97678009925 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0381.md @@ -0,0 +1,20 @@ +It is not allowed to use or capture an uninitialized variable. + +Erroneous code example: + +```compile_fail,E0381 +fn main() { + let x: i32; + let y = x; // error, use of possibly-uninitialized variable +} +``` + +To fix this, ensure that any declared variables are initialized before being +used. Example: + +``` +fn main() { + let x: i32 = 0; + let y = x; // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0382.md b/src/librustc_error_codes/error_codes/E0382.md new file mode 100644 index 00000000000..1592eac2ec5 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0382.md @@ -0,0 +1,110 @@ +This error occurs when an attempt is made to use a variable after its contents +have been moved elsewhere. + +Erroneous code example: + +```compile_fail,E0382 +struct MyStruct { s: u32 } + +fn main() { + let mut x = MyStruct{ s: 5u32 }; + let y = x; + x.s = 6; + println!("{}", x.s); +} +``` + +Since `MyStruct` is a type that is not marked `Copy`, the data gets moved out +of `x` when we set `y`. This is fundamental to Rust's ownership system: outside +of workarounds like `Rc`, a value cannot be owned by more than one variable. + +Sometimes we don't need to move the value. Using a reference, we can let another +function borrow the value without changing its ownership. In the example below, +we don't actually have to move our string to `calculate_length`, we can give it +a reference to it with `&` instead. + +``` +fn main() { + let s1 = String::from("hello"); + + let len = calculate_length(&s1); + + println!("The length of '{}' is {}.", s1, len); +} + +fn calculate_length(s: &String) -> usize { + s.len() +} +``` + +A mutable reference can be created with `&mut`. + +Sometimes we don't want a reference, but a duplicate. All types marked `Clone` +can be duplicated by calling `.clone()`. Subsequent changes to a clone do not +affect the original variable. + +Most types in the standard library are marked `Clone`. The example below +demonstrates using `clone()` on a string. `s1` is first set to "many", and then +copied to `s2`. Then the first character of `s1` is removed, without affecting +`s2`. "any many" is printed to the console. + +``` +fn main() { + let mut s1 = String::from("many"); + let s2 = s1.clone(); + s1.remove(0); + println!("{} {}", s1, s2); +} +``` + +If we control the definition of a type, we can implement `Clone` on it ourselves +with `#[derive(Clone)]`. + +Some types have no ownership semantics at all and are trivial to duplicate. An +example is `i32` and the other number types. We don't have to call `.clone()` to +clone them, because they are marked `Copy` in addition to `Clone`. Implicit +cloning is more convenient in this case. We can mark our own types `Copy` if +all their members also are marked `Copy`. + +In the example below, we implement a `Point` type. Because it only stores two +integers, we opt-out of ownership semantics with `Copy`. Then we can +`let p2 = p1` without `p1` being moved. + +``` +#[derive(Copy, Clone)] +struct Point { x: i32, y: i32 } + +fn main() { + let mut p1 = Point{ x: -1, y: 2 }; + let p2 = p1; + p1.x = 1; + println!("p1: {}, {}", p1.x, p1.y); + println!("p2: {}, {}", p2.x, p2.y); +} +``` + +Alternatively, if we don't control the struct's definition, or mutable shared +ownership is truly required, we can use `Rc` and `RefCell`: + +``` +use std::cell::RefCell; +use std::rc::Rc; + +struct MyStruct { s: u32 } + +fn main() { + let mut x = Rc::new(RefCell::new(MyStruct{ s: 5u32 })); + let y = x.clone(); + x.borrow_mut().s = 6; + println!("{}", x.borrow().s); +} +``` + +With this approach, x and y share ownership of the data via the `Rc` (reference +count type). `RefCell` essentially performs runtime borrow checking: ensuring +that at most one writer or multiple readers can access the data at any one time. + +If you wish to learn more about ownership in Rust, start with the chapter in the +Book: + +https://doc.rust-lang.org/book/ch04-00-understanding-ownership.html diff --git a/src/librustc_error_codes/error_codes/E0383.md b/src/librustc_error_codes/error_codes/E0383.md new file mode 100644 index 00000000000..fd2b0b08fb0 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0383.md @@ -0,0 +1,34 @@ +#### Note: this error code is no longer emitted by the compiler. + +This error occurs when an attempt is made to partially reinitialize a +structure that is currently uninitialized. + +For example, this can happen when a drop has taken place: + +```compile_fail +struct Foo { + a: u32, +} +impl Drop for Foo { + fn drop(&mut self) { /* ... */ } +} + +let mut x = Foo { a: 1 }; +drop(x); // `x` is now uninitialized +x.a = 2; // error, partial reinitialization of uninitialized structure `t` +``` + +This error can be fixed by fully reinitializing the structure in question: + +``` +struct Foo { + a: u32, +} +impl Drop for Foo { + fn drop(&mut self) { /* ... */ } +} + +let mut x = Foo { a: 1 }; +drop(x); +x = Foo { a: 2 }; +``` diff --git a/src/librustc_error_codes/error_codes/E0384.md b/src/librustc_error_codes/error_codes/E0384.md new file mode 100644 index 00000000000..7c7ee744a8c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0384.md @@ -0,0 +1,20 @@ +This error occurs when an attempt is made to reassign an immutable variable. + +Erroneous code example: + +```compile_fail,E0384 +fn main() { + let x = 3; + x = 5; // error, reassignment of immutable variable +} +``` + +By default, variables in Rust are immutable. To fix this error, add the keyword +`mut` after the keyword `let` when declaring the variable. For example: + +``` +fn main() { + let mut x = 3; + x = 5; +} +``` diff --git a/src/librustc_error_codes/error_codes/E0386.md b/src/librustc_error_codes/error_codes/E0386.md new file mode 100644 index 00000000000..de3b468b6e4 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0386.md @@ -0,0 +1,31 @@ +#### Note: this error code is no longer emitted by the compiler. + +This error occurs when an attempt is made to mutate the target of a mutable +reference stored inside an immutable container. + +For example, this can happen when storing a `&mut` inside an immutable `Box`: + +``` +let mut x: i64 = 1; +let y: Box<_> = Box::new(&mut x); +**y = 2; // error, cannot assign to data in an immutable container +``` + +This error can be fixed by making the container mutable: + +``` +let mut x: i64 = 1; +let mut y: Box<_> = Box::new(&mut x); +**y = 2; +``` + +It can also be fixed by using a type with interior mutability, such as `Cell` +or `RefCell`: + +``` +use std::cell::Cell; + +let x: i64 = 1; +let y: Box<Cell<_>> = Box::new(Cell::new(x)); +y.set(2); +``` diff --git a/src/librustc_error_codes/error_codes/E0387.md b/src/librustc_error_codes/error_codes/E0387.md new file mode 100644 index 00000000000..3a5facfdd25 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0387.md @@ -0,0 +1,57 @@ +#### Note: this error code is no longer emitted by the compiler. + +This error occurs when an attempt is made to mutate or mutably reference data +that a closure has captured immutably. + +Erroneous code example: + +```compile_fail +// Accepts a function or a closure that captures its environment immutably. +// Closures passed to foo will not be able to mutate their closed-over state. +fn foo<F: Fn()>(f: F) { } + +// Attempts to mutate closed-over data. Error message reads: +// `cannot assign to data in a captured outer variable...` +fn mutable() { + let mut x = 0u32; + foo(|| x = 2); +} + +// Attempts to take a mutable reference to closed-over data. Error message +// reads: `cannot borrow data mutably in a captured outer variable...` +fn mut_addr() { + let mut x = 0u32; + foo(|| { let y = &mut x; }); +} +``` + +The problem here is that foo is defined as accepting a parameter of type `Fn`. +Closures passed into foo will thus be inferred to be of type `Fn`, meaning that +they capture their context immutably. + +If the definition of `foo` is under your control, the simplest solution is to +capture the data mutably. This can be done by defining `foo` to take FnMut +rather than Fn: + +``` +fn foo<F: FnMut()>(f: F) { } +``` + +Alternatively, we can consider using the `Cell` and `RefCell` types to achieve +interior mutability through a shared reference. Our example's `mutable` +function could be redefined as below: + +``` +use std::cell::Cell; + +fn foo<F: Fn()>(f: F) { } + +fn mutable() { + let x = Cell::new(0u32); + foo(|| x.set(2)); +} +``` + +You can read more about cell types in the API documentation: + +https://doc.rust-lang.org/std/cell/ diff --git a/src/librustc_error_codes/error_codes/E0388.md b/src/librustc_error_codes/error_codes/E0388.md new file mode 100644 index 00000000000..512fb42e6ec --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0388.md @@ -0,0 +1 @@ +#### Note: this error code is no longer emitted by the compiler. diff --git a/src/librustc_error_codes/error_codes/E0389.md b/src/librustc_error_codes/error_codes/E0389.md new file mode 100644 index 00000000000..9f064e44c82 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0389.md @@ -0,0 +1,63 @@ +#### Note: this error code is no longer emitted by the compiler. + +An attempt was made to mutate data using a non-mutable reference. This +commonly occurs when attempting to assign to a non-mutable reference of a +mutable reference (`&(&mut T)`). + +Erroneous code example: + +```compile_fail +struct FancyNum { + num: u8, +} + +fn main() { + let mut fancy = FancyNum{ num: 5 }; + let fancy_ref = &(&mut fancy); + fancy_ref.num = 6; // error: cannot assign to data in a `&` reference + println!("{}", fancy_ref.num); +} +``` + +Here, `&mut fancy` is mutable, but `&(&mut fancy)` is not. Creating an +immutable reference to a value borrows it immutably. There can be multiple +references of type `&(&mut T)` that point to the same value, so they must be +immutable to prevent multiple mutable references to the same value. + +To fix this, either remove the outer reference: + +``` +struct FancyNum { + num: u8, +} + +fn main() { + let mut fancy = FancyNum{ num: 5 }; + + let fancy_ref = &mut fancy; + // `fancy_ref` is now &mut FancyNum, rather than &(&mut FancyNum) + + fancy_ref.num = 6; // No error! + + println!("{}", fancy_ref.num); +} +``` + +Or make the outer reference mutable: + +``` +struct FancyNum { + num: u8 +} + +fn main() { + let mut fancy = FancyNum{ num: 5 }; + + let fancy_ref = &mut (&mut fancy); + // `fancy_ref` is now &mut(&mut FancyNum), rather than &(&mut FancyNum) + + fancy_ref.num = 6; // No error! + + println!("{}", fancy_ref.num); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0390.md b/src/librustc_error_codes/error_codes/E0390.md new file mode 100644 index 00000000000..9d05740d6f5 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0390.md @@ -0,0 +1,28 @@ +You tried to implement methods for a primitive type. Erroneous code example: + +```compile_fail,E0390 +struct Foo { + x: i32 +} + +impl *mut Foo {} +// error: only a single inherent implementation marked with +// `#[lang = "mut_ptr"]` is allowed for the `*mut T` primitive +``` + +This isn't allowed, but using a trait to implement a method is a good solution. +Example: + +``` +struct Foo { + x: i32 +} + +trait Bar { + fn bar(); +} + +impl Bar for *mut Foo { + fn bar() {} // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0391.md b/src/librustc_error_codes/error_codes/E0391.md new file mode 100644 index 00000000000..5db9ad16d08 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0391.md @@ -0,0 +1,14 @@ +This error indicates that some types or traits depend on each other +and therefore cannot be constructed. + +The following example contains a circular dependency between two traits: + +```compile_fail,E0391 +trait FirstTrait : SecondTrait { + +} + +trait SecondTrait : FirstTrait { + +} +``` diff --git a/src/librustc_error_codes/error_codes/E0392.md b/src/librustc_error_codes/error_codes/E0392.md new file mode 100644 index 00000000000..1d93e904e37 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0392.md @@ -0,0 +1,57 @@ +This error indicates that a type or lifetime parameter has been declared +but not actually used. Here is an example that demonstrates the error: + +```compile_fail,E0392 +enum Foo<T> { + Bar, +} +``` + +If the type parameter was included by mistake, this error can be fixed +by simply removing the type parameter, as shown below: + +``` +enum Foo { + Bar, +} +``` + +Alternatively, if the type parameter was intentionally inserted, it must be +used. A simple fix is shown below: + +``` +enum Foo<T> { + Bar(T), +} +``` + +This error may also commonly be found when working with unsafe code. For +example, when using raw pointers one may wish to specify the lifetime for +which the pointed-at data is valid. An initial attempt (below) causes this +error: + +```compile_fail,E0392 +struct Foo<'a, T> { + x: *const T, +} +``` + +We want to express the constraint that Foo should not outlive `'a`, because +the data pointed to by `T` is only valid for that lifetime. The problem is +that there are no actual uses of `'a`. It's possible to work around this +by adding a PhantomData type to the struct, using it to tell the compiler +to act as if the struct contained a borrowed reference `&'a T`: + +``` +use std::marker::PhantomData; + +struct Foo<'a, T: 'a> { + x: *const T, + phantom: PhantomData<&'a T> +} +``` + +[PhantomData] can also be used to express information about unused type +parameters. + +[PhantomData]: https://doc.rust-lang.org/std/marker/struct.PhantomData.html diff --git a/src/librustc_error_codes/error_codes/E0393.md b/src/librustc_error_codes/error_codes/E0393.md new file mode 100644 index 00000000000..7cce99401cf --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0393.md @@ -0,0 +1,28 @@ +A type parameter which references `Self` in its default value was not specified. +Example of erroneous code: + +```compile_fail,E0393 +trait A<T=Self> {} + +fn together_we_will_rule_the_galaxy(son: &A) {} +// error: the type parameter `T` must be explicitly specified in an +// object type because its default value `Self` references the +// type `Self` +``` + +A trait object is defined over a single, fully-defined trait. With a regular +default parameter, this parameter can just be substituted in. However, if the +default parameter is `Self`, the trait changes for each concrete type; i.e. +`i32` will be expected to implement `A<i32>`, `bool` will be expected to +implement `A<bool>`, etc... These types will not share an implementation of a +fully-defined trait; instead they share implementations of a trait with +different parameters substituted in for each implementation. This is +irreconcilable with what we need to make a trait object work, and is thus +disallowed. Making the trait concrete by explicitly specifying the value of the +defaulted parameter will fix this issue. Fixed example: + +``` +trait A<T=Self> {} + +fn together_we_will_rule_the_galaxy(son: &A<i32>) {} // Ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0398.md b/src/librustc_error_codes/error_codes/E0398.md new file mode 100644 index 00000000000..75d86979e3c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0398.md @@ -0,0 +1,35 @@ +#### Note: this error code is no longer emitted by the compiler. + +In Rust 1.3, the default object lifetime bounds are expected to change, as +described in [RFC 1156]. You are getting a warning because the compiler +thinks it is possible that this change will cause a compilation error in your +code. It is possible, though unlikely, that this is a false alarm. + +The heart of the change is that where `&'a Box<SomeTrait>` used to default to +`&'a Box<SomeTrait+'a>`, it now defaults to `&'a Box<SomeTrait+'static>` (here, +`SomeTrait` is the name of some trait type). Note that the only types which are +affected are references to boxes, like `&Box<SomeTrait>` or +`&[Box<SomeTrait>]`. More common types like `&SomeTrait` or `Box<SomeTrait>` +are unaffected. + +To silence this warning, edit your code to use an explicit bound. Most of the +time, this means that you will want to change the signature of a function that +you are calling. For example, if the error is reported on a call like `foo(x)`, +and `foo` is defined as follows: + +``` +# trait SomeTrait {} +fn foo(arg: &Box<SomeTrait>) { /* ... */ } +``` + +You might change it to: + +``` +# trait SomeTrait {} +fn foo<'a>(arg: &'a Box<SomeTrait+'a>) { /* ... */ } +``` + +This explicitly states that you expect the trait object `SomeTrait` to contain +references (with a maximum lifetime of `'a`). + +[RFC 1156]: https://github.com/rust-lang/rfcs/blob/master/text/1156-adjust-default-object-bounds.md diff --git a/src/librustc_error_codes/error_codes/E0399.md b/src/librustc_error_codes/error_codes/E0399.md new file mode 100644 index 00000000000..71482c3ca64 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0399.md @@ -0,0 +1,35 @@ +You implemented a trait, overriding one or more of its associated types but did +not reimplement its default methods. + +Example of erroneous code: + +```compile_fail,E0399 +#![feature(associated_type_defaults)] + +pub trait Foo { + type Assoc = u8; + fn bar(&self) {} +} + +impl Foo for i32 { + // error - the following trait items need to be reimplemented as + // `Assoc` was overridden: `bar` + type Assoc = i32; +} +``` + +To fix this, add an implementation for each default method from the trait: + +``` +#![feature(associated_type_defaults)] + +pub trait Foo { + type Assoc = u8; + fn bar(&self) {} +} + +impl Foo for i32 { + type Assoc = i32; + fn bar(&self) {} // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0401.md b/src/librustc_error_codes/error_codes/E0401.md new file mode 100644 index 00000000000..4c93053d5f8 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0401.md @@ -0,0 +1,106 @@ +Inner items do not inherit type or const parameters from the functions +they are embedded in. + +Erroneous code example: + +```compile_fail,E0401 +fn foo<T>(x: T) { + fn bar(y: T) { // T is defined in the "outer" function + // .. + } + bar(x); +} +``` + +Nor will this: + +```compile_fail,E0401 +fn foo<T>(x: T) { + type MaybeT = Option<T>; + // ... +} +``` + +Or this: + +```compile_fail,E0401 +fn foo<T>(x: T) { + struct Foo { + x: T, + } + // ... +} +``` + +Items inside functions are basically just like top-level items, except +that they can only be used from the function they are in. + +There are a couple of solutions for this. + +If the item is a function, you may use a closure: + +``` +fn foo<T>(x: T) { + let bar = |y: T| { // explicit type annotation may not be necessary + // .. + }; + bar(x); +} +``` + +For a generic item, you can copy over the parameters: + +``` +fn foo<T>(x: T) { + fn bar<T>(y: T) { + // .. + } + bar(x); +} +``` + +``` +fn foo<T>(x: T) { + type MaybeT<T> = Option<T>; +} +``` + +Be sure to copy over any bounds as well: + +``` +fn foo<T: Copy>(x: T) { + fn bar<T: Copy>(y: T) { + // .. + } + bar(x); +} +``` + +``` +fn foo<T: Copy>(x: T) { + struct Foo<T: Copy> { + x: T, + } +} +``` + +This may require additional type hints in the function body. + +In case the item is a function inside an `impl`, defining a private helper +function might be easier: + +``` +# struct Foo<T>(T); +impl<T> Foo<T> { + pub fn foo(&self, x: T) { + self.bar(x); + } + + fn bar(&self, y: T) { + // .. + } +} +``` + +For default impls in traits, the private helper solution won't work, however +closures or copying the parameters should still work. diff --git a/src/librustc_error_codes/error_codes/E0403.md b/src/librustc_error_codes/error_codes/E0403.md new file mode 100644 index 00000000000..5f4a40ce92e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0403.md @@ -0,0 +1,25 @@ +Some type parameters have the same name. + +Erroneous code example: + +```compile_fail,E0403 +fn f<T, T>(s: T, u: T) {} // error: the name `T` is already used for a generic + // parameter in this item's generic parameters +``` + +Please verify that none of the type parameters are misspelled, and rename any +clashing parameters. Example: + +``` +fn f<T, Y>(s: T, u: Y) {} // ok! +``` + +Type parameters in an associated item also cannot shadow parameters from the +containing item: + +```compile_fail,E0403 +trait Foo<T> { + fn do_something(&self) -> T; + fn do_something_else<T: Clone>(&self, bar: T); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0404.md b/src/librustc_error_codes/error_codes/E0404.md new file mode 100644 index 00000000000..861a50bfd8c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0404.md @@ -0,0 +1,44 @@ +You tried to use something which is not a trait in a trait position, such as +a bound or `impl`. + +Erroneous code example: + +```compile_fail,E0404 +struct Foo; +struct Bar; + +impl Foo for Bar {} // error: `Foo` is not a trait +``` + +Another erroneous code example: + +```compile_fail,E0404 +struct Foo; + +fn bar<T: Foo>(t: T) {} // error: `Foo` is not a trait +``` + +Please verify that you didn't misspell the trait's name or otherwise use the +wrong identifier. Example: + +``` +trait Foo { + // some functions +} +struct Bar; + +impl Foo for Bar { // ok! + // functions implementation +} +``` + +or + +``` +trait Foo { + // some functions +} + +fn bar<T: Foo>(t: T) {} // ok! +``` + diff --git a/src/librustc_error_codes/error_codes/E0405.md b/src/librustc_error_codes/error_codes/E0405.md new file mode 100644 index 00000000000..ff1e8c0be88 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0405.md @@ -0,0 +1,29 @@ +The code refers to a trait that is not in scope. + +Erroneous code example: + +```compile_fail,E0405 +struct Foo; + +impl SomeTrait for Foo {} // error: trait `SomeTrait` is not in scope +``` + +Please verify that the name of the trait wasn't misspelled and ensure that it +was imported. Example: + +``` +# #[cfg(for_demonstration_only)] +// solution 1: +use some_file::SomeTrait; + +// solution 2: +trait SomeTrait { + // some functions +} + +struct Foo; + +impl SomeTrait for Foo { // ok! + // implements functions +} +``` diff --git a/src/librustc_error_codes/error_codes/E0407.md b/src/librustc_error_codes/error_codes/E0407.md new file mode 100644 index 00000000000..fa26c77a1b0 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0407.md @@ -0,0 +1,52 @@ +A definition of a method not in the implemented trait was given in a trait +implementation. + +Erroneous code example: + +```compile_fail,E0407 +trait Foo { + fn a(); +} + +struct Bar; + +impl Foo for Bar { + fn a() {} + fn b() {} // error: method `b` is not a member of trait `Foo` +} +``` + +Please verify you didn't misspell the method name and you used the correct +trait. First example: + +``` +trait Foo { + fn a(); + fn b(); +} + +struct Bar; + +impl Foo for Bar { + fn a() {} + fn b() {} // ok! +} +``` + +Second example: + +``` +trait Foo { + fn a(); +} + +struct Bar; + +impl Foo for Bar { + fn a() {} +} + +impl Bar { + fn b() {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0408.md b/src/librustc_error_codes/error_codes/E0408.md new file mode 100644 index 00000000000..3acdbb740a3 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0408.md @@ -0,0 +1,41 @@ +An "or" pattern was used where the variable bindings are not consistently bound +across patterns. + +Erroneous code example: + +```compile_fail,E0408 +match x { + Some(y) | None => { /* use y */ } // error: variable `y` from pattern #1 is + // not bound in pattern #2 + _ => () +} +``` + +Here, `y` is bound to the contents of the `Some` and can be used within the +block corresponding to the match arm. However, in case `x` is `None`, we have +not specified what `y` is, and the block will use a nonexistent variable. + +To fix this error, either split into multiple match arms: + +``` +let x = Some(1); +match x { + Some(y) => { /* use y */ } + None => { /* ... */ } +} +``` + +or, bind the variable to a field of the same type in all sub-patterns of the +or pattern: + +``` +let x = (0, 2); +match x { + (0, y) | (y, 0) => { /* use y */} + _ => {} +} +``` + +In this example, if `x` matches the pattern `(0, _)`, the second field is set +to `y`. If it matches `(_, 0)`, the first field is set to `y`; so in all +cases `y` is set to some value. diff --git a/src/librustc_error_codes/error_codes/E0409.md b/src/librustc_error_codes/error_codes/E0409.md new file mode 100644 index 00000000000..53eb0fd0573 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0409.md @@ -0,0 +1,38 @@ +An "or" pattern was used where the variable bindings are not consistently bound +across patterns. + +Erroneous code example: + +```compile_fail,E0409 +let x = (0, 2); +match x { + (0, ref y) | (y, 0) => { /* use y */} // error: variable `y` is bound with + // different mode in pattern #2 + // than in pattern #1 + _ => () +} +``` + +Here, `y` is bound by-value in one case and by-reference in the other. + +To fix this error, just use the same mode in both cases. +Generally using `ref` or `ref mut` where not already used will fix this: + +``` +let x = (0, 2); +match x { + (0, ref y) | (ref y, 0) => { /* use y */} + _ => () +} +``` + +Alternatively, split the pattern: + +``` +let x = (0, 2); +match x { + (y, 0) => { /* use y */ } + (0, ref y) => { /* use y */} + _ => () +} +``` diff --git a/src/librustc_error_codes/error_codes/E0411.md b/src/librustc_error_codes/error_codes/E0411.md new file mode 100644 index 00000000000..d82171533ae --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0411.md @@ -0,0 +1,56 @@ +The `Self` keyword was used outside an impl, trait, or type definition. + +Erroneous code example: + +```compile_fail,E0411 +<Self>::foo; // error: use of `Self` outside of an impl, trait, or type + // definition +``` + +The `Self` keyword represents the current type, which explains why it can only +be used inside an impl, trait, or type definition. It gives access to the +associated items of a type: + +``` +trait Foo { + type Bar; +} + +trait Baz : Foo { + fn bar() -> Self::Bar; // like this +} +``` + +However, be careful when two types have a common associated type: + +```compile_fail +trait Foo { + type Bar; +} + +trait Foo2 { + type Bar; +} + +trait Baz : Foo + Foo2 { + fn bar() -> Self::Bar; + // error: ambiguous associated type `Bar` in bounds of `Self` +} +``` + +This problem can be solved by specifying from which trait we want to use the +`Bar` type: + +``` +trait Foo { + type Bar; +} + +trait Foo2 { + type Bar; +} + +trait Baz : Foo + Foo2 { + fn bar() -> <Self as Foo>::Bar; // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0412.md b/src/librustc_error_codes/error_codes/E0412.md new file mode 100644 index 00000000000..60a09610d86 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0412.md @@ -0,0 +1,64 @@ +The type name used is not in scope. + +Erroneous code examples: + +```compile_fail,E0412 +impl Something {} // error: type name `Something` is not in scope + +// or: + +trait Foo { + fn bar(N); // error: type name `N` is not in scope +} + +// or: + +fn foo(x: T) {} // type name `T` is not in scope +``` + +To fix this error, please verify you didn't misspell the type name, you did +declare it or imported it into the scope. Examples: + +``` +struct Something; + +impl Something {} // ok! + +// or: + +trait Foo { + type N; + + fn bar(_: Self::N); // ok! +} + +// or: + +fn foo<T>(x: T) {} // ok! +``` + +Another case that causes this error is when a type is imported into a parent +module. To fix this, you can follow the suggestion and use File directly or +`use super::File;` which will import the types from the parent namespace. An +example that causes this error is below: + +```compile_fail,E0412 +use std::fs::File; + +mod foo { + fn some_function(f: File) {} +} +``` + +``` +use std::fs::File; + +mod foo { + // either + use super::File; + // or + // use std::fs::File; + fn foo(f: File) {} +} +# fn main() {} // don't insert it for us; that'll break imports +``` diff --git a/src/librustc_error_codes/error_codes/E0415.md b/src/librustc_error_codes/error_codes/E0415.md new file mode 100644 index 00000000000..97d733a7b2d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0415.md @@ -0,0 +1,14 @@ +More than one function parameter have the same name. + +Erroneous code example: + +```compile_fail,E0415 +fn foo(f: i32, f: i32) {} // error: identifier `f` is bound more than + // once in this parameter list +``` + +Please verify you didn't misspell parameters' name. Example: + +``` +fn foo(f: i32, g: i32) {} // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0416.md b/src/librustc_error_codes/error_codes/E0416.md new file mode 100644 index 00000000000..7bc316dafc5 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0416.md @@ -0,0 +1,28 @@ +An identifier is bound more than once in a pattern. + +Erroneous code example: + +```compile_fail,E0416 +match (1, 2) { + (x, x) => {} // error: identifier `x` is bound more than once in the + // same pattern +} +``` + +Please verify you didn't misspell identifiers' name. Example: + +``` +match (1, 2) { + (x, y) => {} // ok! +} +``` + +Or maybe did you mean to unify? Consider using a guard: + +``` +# let (A, B, C) = (1, 2, 3); +match (A, B, C) { + (x, x2, see) if x == x2 => { /* A and B are equal, do one thing */ } + (y, z, see) => { /* A and B unequal; do another thing */ } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0422.md b/src/librustc_error_codes/error_codes/E0422.md new file mode 100644 index 00000000000..a91ea6a9e22 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0422.md @@ -0,0 +1,21 @@ +You are trying to use an identifier that is either undefined or not a struct. +Erroneous code example: + +```compile_fail,E0422 +fn main () { + let x = Foo { x: 1, y: 2 }; +} +``` + +In this case, `Foo` is undefined, so it inherently isn't anything, and +definitely not a struct. + +```compile_fail +fn main () { + let foo = 1; + let x = foo { x: 1, y: 2 }; +} +``` + +In this case, `foo` is defined, but is not a struct, so Rust can't use it as +one. diff --git a/src/librustc_error_codes/error_codes/E0423.md b/src/librustc_error_codes/error_codes/E0423.md new file mode 100644 index 00000000000..6a7c31f5e0d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0423.md @@ -0,0 +1,47 @@ +An identifier was used like a function name or a value was expected and the +identifier exists but it belongs to a different namespace. + +For (an erroneous) example, here a `struct` variant name were used as a +function: + +```compile_fail,E0423 +struct Foo { a: bool }; + +let f = Foo(); +// error: expected function, tuple struct or tuple variant, found `Foo` +// `Foo` is a struct name, but this expression uses it like a function name +``` + +Please verify you didn't misspell the name of what you actually wanted to use +here. Example: + +``` +fn Foo() -> u32 { 0 } + +let f = Foo(); // ok! +``` + +It is common to forget the trailing `!` on macro invocations, which would also +yield this error: + +```compile_fail,E0423 +println(""); +// error: expected function, tuple struct or tuple variant, +// found macro `println` +// did you mean `println!(...)`? (notice the trailing `!`) +``` + +Another case where this error is emitted is when a value is expected, but +something else is found: + +```compile_fail,E0423 +pub mod a { + pub const I: i32 = 1; +} + +fn h1() -> i32 { + a.I + //~^ ERROR expected value, found module `a` + // did you mean `a::I`? +} +``` diff --git a/src/librustc_error_codes/error_codes/E0424.md b/src/librustc_error_codes/error_codes/E0424.md new file mode 100644 index 00000000000..a9f6f579b42 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0424.md @@ -0,0 +1,40 @@ +The `self` keyword was used inside of an associated function without a "`self` +receiver" parameter. + +Erroneous code example: + +```compile_fail,E0424 +struct Foo; + +impl Foo { + // `bar` is a method, because it has a receiver parameter. + fn bar(&self) {} + + // `foo` is not a method, because it has no receiver parameter. + fn foo() { + self.bar(); // error: `self` value is a keyword only available in + // methods with a `self` parameter + } +} +``` + +The `self` keyword can only be used inside methods, which are associated +functions (functions defined inside of a `trait` or `impl` block) that have a +`self` receiver as its first parameter, like `self`, `&self`, `&mut self` or +`self: &mut Pin<Self>` (this last one is an example of an ["abitrary `self` +type"](https://github.com/rust-lang/rust/issues/44874)). + +Check if the associated function's parameter list should have contained a `self` +receiver for it to be a method, and add it if so. Example: + +``` +struct Foo; + +impl Foo { + fn bar(&self) {} + + fn foo(self) { // `foo` is now a method. + self.bar(); // ok! + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0425.md b/src/librustc_error_codes/error_codes/E0425.md new file mode 100644 index 00000000000..13e71b85065 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0425.md @@ -0,0 +1,60 @@ +An unresolved name was used. + +Erroneous code examples: + +```compile_fail,E0425 +something_that_doesnt_exist::foo; +// error: unresolved name `something_that_doesnt_exist::foo` + +// or: + +trait Foo { + fn bar() { + Self; // error: unresolved name `Self` + } +} + +// or: + +let x = unknown_variable; // error: unresolved name `unknown_variable` +``` + +Please verify that the name wasn't misspelled and ensure that the +identifier being referred to is valid for the given situation. Example: + +``` +enum something_that_does_exist { + Foo, +} +``` + +Or: + +``` +mod something_that_does_exist { + pub static foo : i32 = 0i32; +} + +something_that_does_exist::foo; // ok! +``` + +Or: + +``` +let unknown_variable = 12u32; +let x = unknown_variable; // ok! +``` + +If the item is not defined in the current module, it must be imported using a +`use` statement, like so: + +``` +# mod foo { pub fn bar() {} } +# fn main() { +use foo::bar; +bar(); +# } +``` + +If the item you are importing is not defined in some super-module of the +current module, then it must also be declared as public (e.g., `pub fn`). diff --git a/src/librustc_error_codes/error_codes/E0426.md b/src/librustc_error_codes/error_codes/E0426.md new file mode 100644 index 00000000000..15e7fb04738 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0426.md @@ -0,0 +1,17 @@ +An undeclared label was used. + +Erroneous code example: + +```compile_fail,E0426 +loop { + break 'a; // error: use of undeclared label `'a` +} +``` + +Please verify you spelt or declare the label correctly. Example: + +``` +'a: loop { + break 'a; // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0428.md b/src/librustc_error_codes/error_codes/E0428.md new file mode 100644 index 00000000000..38db0b4bcf9 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0428.md @@ -0,0 +1,16 @@ +A type or module has been defined more than once. + +Erroneous code example: + +```compile_fail,E0428 +struct Bar; +struct Bar; // error: duplicate definition of value `Bar` +``` + +Please verify you didn't misspell the type/module's name or remove/rename the +duplicated one. Example: + +``` +struct Bar; +struct Bar2; // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0429.md b/src/librustc_error_codes/error_codes/E0429.md new file mode 100644 index 00000000000..8c5fd8624fd --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0429.md @@ -0,0 +1,21 @@ +The `self` keyword cannot appear alone as the last segment in a `use` +declaration. + +Erroneous code example: + +```compile_fail,E0429 +use std::fmt::self; // error: `self` imports are only allowed within a { } list +``` + +To use a namespace itself in addition to some of its members, `self` may appear +as part of a brace-enclosed list of imports: + +``` +use std::fmt::{self, Debug}; +``` + +If you only want to import the namespace, do so directly: + +``` +use std::fmt; +``` diff --git a/src/librustc_error_codes/error_codes/E0430.md b/src/librustc_error_codes/error_codes/E0430.md new file mode 100644 index 00000000000..8cca0f21e59 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0430.md @@ -0,0 +1,18 @@ +The `self` import appears more than once in the list. + +Erroneous code example: + +```compile_fail,E0430 +use something::{self, self}; // error: `self` import can only appear once in + // the list +``` + +Please verify you didn't misspell the import name or remove the duplicated +`self` import. Example: + +``` +# mod something {} +# fn main() { +use something::{self}; // ok! +# } +``` diff --git a/src/librustc_error_codes/error_codes/E0431.md b/src/librustc_error_codes/error_codes/E0431.md new file mode 100644 index 00000000000..1b70f5f1d7b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0431.md @@ -0,0 +1,11 @@ +An invalid `self` import was made. + +Erroneous code example: + +```compile_fail,E0431 +use {self}; // error: `self` import can only appear in an import list with a + // non-empty prefix +``` + +You cannot import the current module into itself, please remove this import +or verify you didn't misspell it. diff --git a/src/librustc_error_codes/error_codes/E0432.md b/src/librustc_error_codes/error_codes/E0432.md new file mode 100644 index 00000000000..b562a85b785 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0432.md @@ -0,0 +1,32 @@ +An import was unresolved. + +Erroneous code example: + +```compile_fail,E0432 +use something::Foo; // error: unresolved import `something::Foo`. +``` + +Paths in `use` statements are relative to the crate root. To import items +relative to the current and parent modules, use the `self::` and `super::` +prefixes, respectively. Also verify that you didn't misspell the import +name and that the import exists in the module from where you tried to +import it. Example: + +``` +use self::something::Foo; // ok! + +mod something { + pub struct Foo; +} +# fn main() {} +``` + +Or, if you tried to use a module from an external crate, you may have missed +the `extern crate` declaration (which is usually placed in the crate root): + +``` +extern crate core; // Required to use the `core` crate + +use core::any; +# fn main() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0433.md b/src/librustc_error_codes/error_codes/E0433.md new file mode 100644 index 00000000000..f9e333e8ccd --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0433.md @@ -0,0 +1,17 @@ +An undeclared type or module was used. + +Erroneous code example: + +```compile_fail,E0433 +let map = HashMap::new(); +// error: failed to resolve: use of undeclared type or module `HashMap` +``` + +Please verify you didn't misspell the type/module's name or that you didn't +forget to import it: + + +``` +use std::collections::HashMap; // HashMap has been imported. +let map: HashMap<u32, u32> = HashMap::new(); // So it can be used! +``` diff --git a/src/librustc_error_codes/error_codes/E0434.md b/src/librustc_error_codes/error_codes/E0434.md new file mode 100644 index 00000000000..e093f0796da --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0434.md @@ -0,0 +1,42 @@ +This error indicates that a variable usage inside an inner function is invalid +because the variable comes from a dynamic environment. Inner functions do not +have access to their containing environment. + +Erroneous code example: + +```compile_fail,E0434 +fn foo() { + let y = 5; + fn bar() -> u32 { + y // error: can't capture dynamic environment in a fn item; use the + // || { ... } closure form instead. + } +} +``` + +Functions do not capture local variables. To fix this error, you can replace the +function with a closure: + +``` +fn foo() { + let y = 5; + let bar = || { + y + }; +} +``` + +or replace the captured variable with a constant or a static item: + +``` +fn foo() { + static mut X: u32 = 4; + const Y: u32 = 5; + fn bar() -> u32 { + unsafe { + X = 3; + } + Y + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0435.md b/src/librustc_error_codes/error_codes/E0435.md new file mode 100644 index 00000000000..424e5ce1e2e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0435.md @@ -0,0 +1,21 @@ +A non-constant value was used in a constant expression. + +Erroneous code example: + +```compile_fail,E0435 +let foo = 42; +let a: [u8; foo]; // error: attempt to use a non-constant value in a constant +``` + +To fix this error, please replace the value with a constant. Example: + +``` +let a: [u8; 42]; // ok! +``` + +Or: + +``` +const FOO: usize = 42; +let a: [u8; FOO]; // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0436.md b/src/librustc_error_codes/error_codes/E0436.md new file mode 100644 index 00000000000..b1afd9e9603 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0436.md @@ -0,0 +1,47 @@ +The functional record update syntax is only allowed for structs. (Struct-like +enum variants don't qualify, for example.) + +Erroneous code example: + +```compile_fail,E0436 +enum PublicationFrequency { + Weekly, + SemiMonthly { days: (u8, u8), annual_special: bool }, +} + +fn one_up_competitor(competitor_frequency: PublicationFrequency) + -> PublicationFrequency { + match competitor_frequency { + PublicationFrequency::Weekly => PublicationFrequency::SemiMonthly { + days: (1, 15), annual_special: false + }, + c @ PublicationFrequency::SemiMonthly{ .. } => + PublicationFrequency::SemiMonthly { + annual_special: true, ..c // error: functional record update + // syntax requires a struct + } + } +} +``` + +Rewrite the expression without functional record update syntax: + +``` +enum PublicationFrequency { + Weekly, + SemiMonthly { days: (u8, u8), annual_special: bool }, +} + +fn one_up_competitor(competitor_frequency: PublicationFrequency) + -> PublicationFrequency { + match competitor_frequency { + PublicationFrequency::Weekly => PublicationFrequency::SemiMonthly { + days: (1, 15), annual_special: false + }, + PublicationFrequency::SemiMonthly{ days, .. } => + PublicationFrequency::SemiMonthly { + days, annual_special: true // ok! + } + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0437.md b/src/librustc_error_codes/error_codes/E0437.md new file mode 100644 index 00000000000..834cf33dbc7 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0437.md @@ -0,0 +1,22 @@ +Trait implementations can only implement associated types that are members of +the trait in question. This error indicates that you attempted to implement +an associated type whose name does not match the name of any associated type +in the trait. + +Erroneous code example: + +```compile_fail,E0437 +trait Foo {} + +impl Foo for i32 { + type Bar = bool; +} +``` + +The solution to this problem is to remove the extraneous associated type: + +``` +trait Foo {} + +impl Foo for i32 {} +``` diff --git a/src/librustc_error_codes/error_codes/E0438.md b/src/librustc_error_codes/error_codes/E0438.md new file mode 100644 index 00000000000..cb141a5d24a --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0438.md @@ -0,0 +1,22 @@ +Trait implementations can only implement associated constants that are +members of the trait in question. This error indicates that you +attempted to implement an associated constant whose name does not +match the name of any associated constant in the trait. + +Erroneous code example: + +```compile_fail,E0438 +trait Foo {} + +impl Foo for i32 { + const BAR: bool = true; +} +``` + +The solution to this problem is to remove the extraneous associated constant: + +``` +trait Foo {} + +impl Foo for i32 {} +``` diff --git a/src/librustc_error_codes/error_codes/E0439.md b/src/librustc_error_codes/error_codes/E0439.md new file mode 100644 index 00000000000..e6da2117ac5 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0439.md @@ -0,0 +1,22 @@ +The length of the platform-intrinsic function `simd_shuffle` +wasn't specified. Erroneous code example: + +```compile_fail,E0439 +#![feature(platform_intrinsics)] + +extern "platform-intrinsic" { + fn simd_shuffle<A,B>(a: A, b: A, c: [u32; 8]) -> B; + // error: invalid `simd_shuffle`, needs length: `simd_shuffle` +} +``` + +The `simd_shuffle` function needs the length of the array passed as +last parameter in its name. Example: + +``` +#![feature(platform_intrinsics)] + +extern "platform-intrinsic" { + fn simd_shuffle8<A,B>(a: A, b: A, c: [u32; 8]) -> B; +} +``` diff --git a/src/librustc_error_codes/error_codes/E0445.md b/src/librustc_error_codes/error_codes/E0445.md new file mode 100644 index 00000000000..9cc62b2ba6d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0445.md @@ -0,0 +1,29 @@ +A private trait was used on a public type parameter bound. + +Erroneous code examples: + +```compile_fail,E0445 +#![deny(private_in_public)] + +trait Foo { + fn dummy(&self) { } +} + +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. 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: + +``` +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! +``` diff --git a/src/librustc_error_codes/error_codes/E0446.md b/src/librustc_error_codes/error_codes/E0446.md new file mode 100644 index 00000000000..d0144478dbf --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0446.md @@ -0,0 +1,30 @@ +A private type was used in a public type signature. + +Erroneous code example: + +```compile_fail,E0446 +#![deny(private_in_public)] + +mod Foo { + struct Bar(u32); + + pub fn bar() -> Bar { // error: private type in public interface + Bar(0) + } +} +``` + +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 { + pub struct Bar(u32); // we set the Bar type public + + pub fn bar() -> Bar { // ok! + Bar(0) + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0447.md b/src/librustc_error_codes/error_codes/E0447.md new file mode 100644 index 00000000000..af8cd8d6d52 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0447.md @@ -0,0 +1,15 @@ +#### Note: this error code is no longer emitted by the compiler. + +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. diff --git a/src/librustc_error_codes/error_codes/E0448.md b/src/librustc_error_codes/error_codes/E0448.md new file mode 100644 index 00000000000..ba096f9e984 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0448.md @@ -0,0 +1,28 @@ +#### Note: this error code is no longer emitted by the compiler. + +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, // not ok! +} +``` + +This is the correct syntax: + +``` +pub enum Foo { + Bar, // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0449.md b/src/librustc_error_codes/error_codes/E0449.md new file mode 100644 index 00000000000..a3eb51961d3 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0449.md @@ -0,0 +1,37 @@ +A visibility qualifier was used when it was unnecessary. Erroneous code +examples: + +```compile_fail,E0449 +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 +impl Foo for Bar { + fn foo() {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0451.md b/src/librustc_error_codes/error_codes/E0451.md new file mode 100644 index 00000000000..821073fe16e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0451.md @@ -0,0 +1,48 @@ +A struct constructor with private fields was invoked. + +Erroneous code example: + +```compile_fail,E0451 +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! +``` diff --git a/src/librustc_error_codes/error_codes/E0452.md b/src/librustc_error_codes/error_codes/E0452.md new file mode 100644 index 00000000000..be3d573e10d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0452.md @@ -0,0 +1,14 @@ +An invalid lint attribute has been given. Erroneous code example: + +```compile_fail,E0452 +#![allow(foo = "")] // error: malformed lint attribute +``` + +Lint attributes only accept a list of identifiers (where each identifier is a +lint name). Ensure the attribute is of this form: + +``` +#![allow(foo)] // ok! +// or: +#![allow(foo, foo2)] // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0453.md b/src/librustc_error_codes/error_codes/E0453.md new file mode 100644 index 00000000000..11789db8f36 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0453.md @@ -0,0 +1,42 @@ +A lint check attribute was overruled by a `forbid` directive set as an +attribute on an enclosing scope, or on the command line with the `-F` option. + +Example of erroneous code: + +```compile_fail,E0453 +#![forbid(non_snake_case)] + +#[allow(non_snake_case)] +fn main() { + let MyNumber = 2; // error: allow(non_snake_case) overruled by outer + // forbid(non_snake_case) +} +``` + +The `forbid` lint setting, like `deny`, turns the corresponding compiler +warning into a hard error. Unlike `deny`, `forbid` prevents itself from being +overridden by inner attributes. + +If you're sure you want to override the lint check, you can change `forbid` to +`deny` (or use `-D` instead of `-F` if the `forbid` setting was given as a +command-line option) to allow the inner lint check attribute: + +``` +#![deny(non_snake_case)] + +#[allow(non_snake_case)] +fn main() { + let MyNumber = 2; // ok! +} +``` + +Otherwise, edit the code to pass the lint check, and remove the overruled +attribute: + +``` +#![forbid(non_snake_case)] + +fn main() { + let my_number = 2; +} +``` diff --git a/src/librustc_error_codes/error_codes/E0454.md b/src/librustc_error_codes/error_codes/E0454.md new file mode 100644 index 00000000000..d3314885081 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0454.md @@ -0,0 +1,13 @@ +A link name was given with an empty name. Erroneous code example: + +```ignore (cannot-test-this-because-rustdoc-stops-compile-fail-before-codegen) +#[link(name = "")] extern {} +// error: `#[link(name = "")]` given with empty name +``` + +The rust compiler cannot link to an external library if you don't give it its +name. Example: + +```no_run +#[link(name = "some_lib")] extern {} // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0455.md b/src/librustc_error_codes/error_codes/E0455.md new file mode 100644 index 00000000000..a642528dee2 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0455.md @@ -0,0 +1,19 @@ +Linking with `kind=framework` is only supported when targeting macOS, +as frameworks are specific to that operating system. + +Erroneous code example: + +```ignore (should-compile_fail-but-cannot-doctest-conditionally-without-macos) +#[link(name = "FooCoreServices", kind = "framework")] extern {} +// OS used to compile is Linux for example +``` + +To solve this error you can use conditional compilation: + +``` +#[cfg_attr(target="macos", link(name = "FooCoreServices", kind = "framework"))] +extern {} +``` + +See more: +https://doc.rust-lang.org/reference/attributes.html#conditional-compilation diff --git a/src/librustc_error_codes/error_codes/E0458.md b/src/librustc_error_codes/error_codes/E0458.md new file mode 100644 index 00000000000..e6baeb8f692 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0458.md @@ -0,0 +1,13 @@ +An unknown "kind" was specified for a link attribute. Erroneous code example: + +```ignore (cannot-test-this-because-rustdoc-stops-compile-fail-before-codegen) +#[link(kind = "wonderful_unicorn")] extern {} +// error: unknown kind: `wonderful_unicorn` +``` + +Please specify a valid "kind" value, from one of the following: + +* static +* dylib +* framework + diff --git a/src/librustc_error_codes/error_codes/E0459.md b/src/librustc_error_codes/error_codes/E0459.md new file mode 100644 index 00000000000..663bc322ee6 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0459.md @@ -0,0 +1,13 @@ +A link was used without a name parameter. Erroneous code example: + +```ignore (cannot-test-this-because-rustdoc-stops-compile-fail-before-codegen) +#[link(kind = "dylib")] extern {} +// error: `#[link(...)]` specified without `name = "foo"` +``` + +Please add the name parameter to allow the rust compiler to find the library +you want. Example: + +```no_run +#[link(kind = "dylib", name = "some_lib")] extern {} // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0463.md b/src/librustc_error_codes/error_codes/E0463.md new file mode 100644 index 00000000000..41add698cdc --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0463.md @@ -0,0 +1,11 @@ +A plugin/crate was declared but cannot be found. Erroneous code example: + +```compile_fail,E0463 +#![feature(plugin)] +#![plugin(cookie_monster)] // error: can't find crate for `cookie_monster` +extern crate cake_is_a_lie; // error: can't find crate for `cake_is_a_lie` +``` + +You need to link your code to the relevant crate in order to be able to use it +(through Cargo or the `-L` option of rustc example). Plugins are crates as +well, and you link to them the same way. diff --git a/src/librustc_error_codes/error_codes/E0466.md b/src/librustc_error_codes/error_codes/E0466.md new file mode 100644 index 00000000000..443b7bae134 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0466.md @@ -0,0 +1,34 @@ +Macro import declarations were malformed. + +Erroneous code examples: + +```compile_fail,E0466 +#[macro_use(a_macro(another_macro))] // error: invalid import declaration +extern crate core as some_crate; + +#[macro_use(i_want = "some_macros")] // error: invalid import declaration +extern crate core as another_crate; +``` + +This is a syntax error at the level of attribute declarations. The proper +syntax for macro imports is the following: + +```ignore (cannot-doctest-multicrate-project) +// In some_crate: +#[macro_export] +macro_rules! get_tacos { + ... +} + +#[macro_export] +macro_rules! get_pimientos { + ... +} + +// In your crate: +#[macro_use(get_tacos, get_pimientos)] // It imports `get_tacos` and +extern crate some_crate; // `get_pimientos` macros from some_crate +``` + +If you would like to import all exported macros, write `macro_use` with no +arguments. diff --git a/src/librustc_error_codes/error_codes/E0468.md b/src/librustc_error_codes/error_codes/E0468.md new file mode 100644 index 00000000000..73e3ebb949a --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0468.md @@ -0,0 +1,27 @@ +A non-root module attempts to import macros from another crate. + +Example of erroneous code: + +```compile_fail,E0468 +mod foo { + #[macro_use(debug_assert)] // error: must be at crate root to import + extern crate core; // macros from another crate + fn run_macro() { debug_assert!(true); } +} +``` + +Only `extern crate` imports at the crate root level are allowed to import +macros. + +Either move the macro import to crate root or do without the foreign macros. +This will work: + +``` +#[macro_use(debug_assert)] +extern crate core; + +mod foo { + fn run_macro() { debug_assert!(true); } +} +# fn main() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0469.md b/src/librustc_error_codes/error_codes/E0469.md new file mode 100644 index 00000000000..22db976aac2 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0469.md @@ -0,0 +1,39 @@ +A macro listed for import was not found. + +Erroneous code example: + +```compile_fail,E0469 +#[macro_use(drink, be_merry)] // error: imported macro not found +extern crate alloc; + +fn main() { + // ... +} +``` + +Either the listed macro is not contained in the imported crate, or it is not +exported from the given crate. + +This could be caused by a typo. Did you misspell the macro's name? + +Double-check the names of the macros listed for import, and that the crate +in question exports them. + +A working version would be: + +```ignore (cannot-doctest-multicrate-project) +// In some_crate crate: +#[macro_export] +macro_rules! eat { + ... +} + +#[macro_export] +macro_rules! drink { + ... +} + +// In your crate: +#[macro_use(eat, drink)] +extern crate some_crate; //ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0478.md b/src/librustc_error_codes/error_codes/E0478.md new file mode 100644 index 00000000000..6634d9b6e63 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0478.md @@ -0,0 +1,28 @@ +A lifetime bound was not satisfied. + +Erroneous code example: + +```compile_fail,E0478 +// Check that the explicit lifetime bound (`'SnowWhite`, in this example) must +// outlive all the superbounds from the trait (`'kiss`, in this example). + +trait Wedding<'t>: 't { } + +struct Prince<'kiss, 'SnowWhite> { + child: Box<Wedding<'kiss> + 'SnowWhite>, + // error: lifetime bound not satisfied +} +``` + +In this example, the `'SnowWhite` lifetime is supposed to outlive the `'kiss` +lifetime but the declaration of the `Prince` struct doesn't enforce it. To fix +this issue, you need to specify it: + +``` +trait Wedding<'t>: 't { } + +struct Prince<'kiss, 'SnowWhite: 'kiss> { // You say here that 'kiss must live + // longer than 'SnowWhite. + child: Box<Wedding<'kiss> + 'SnowWhite>, // And now it's all good! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0491.md b/src/librustc_error_codes/error_codes/E0491.md new file mode 100644 index 00000000000..1ccaf71257b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0491.md @@ -0,0 +1,32 @@ +A reference has a longer lifetime than the data it references. + +Erroneous code example: + +```compile_fail,E0491 +trait SomeTrait<'a> { + type Output; +} + +impl<'a, T> SomeTrait<'a> for T { + type Output = &'a T; // compile error E0491 +} +``` + +Here, the problem is that a reference type like `&'a T` is only valid +if all the data in T outlives the lifetime `'a`. But this impl as written +is applicable to any lifetime `'a` and any type `T` -- we have no guarantee +that `T` outlives `'a`. To fix this, you can add a where clause like +`where T: 'a`. + +``` +trait SomeTrait<'a> { + type Output; +} + +impl<'a, T> SomeTrait<'a> for T +where + T: 'a, +{ + type Output = &'a T; // compile error E0491 +} +``` diff --git a/src/librustc_error_codes/error_codes/E0492.md b/src/librustc_error_codes/error_codes/E0492.md new file mode 100644 index 00000000000..1caa59999ae --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0492.md @@ -0,0 +1,71 @@ +A borrow of a constant containing interior mutability was attempted. + +Erroneous code example: + +```compile_fail,E0492 +use std::sync::atomic::AtomicUsize; + +const A: AtomicUsize = AtomicUsize::new(0); +static B: &'static AtomicUsize = &A; +// error: cannot borrow a constant which may contain interior mutability, +// create a static instead +``` + +A `const` represents a constant value that should never change. If one takes +a `&` reference to the constant, then one is taking a pointer to some memory +location containing the value. Normally this is perfectly fine: most values +can't be changed via a shared `&` pointer, but interior mutability would allow +it. That is, a constant value could be mutated. On the other hand, a `static` is +explicitly a single memory location, which can be mutated at will. + +So, in order to solve this error, either use statics which are `Sync`: + +``` +use std::sync::atomic::AtomicUsize; + +static A: AtomicUsize = AtomicUsize::new(0); +static B: &'static AtomicUsize = &A; // ok! +``` + +You can also have this error while using a cell type: + +```compile_fail,E0492 +use std::cell::Cell; + +const A: Cell<usize> = Cell::new(1); +const B: &Cell<usize> = &A; +// error: cannot borrow a constant which may contain interior mutability, +// create a static instead + +// or: +struct C { a: Cell<usize> } + +const D: C = C { a: Cell::new(1) }; +const E: &Cell<usize> = &D.a; // error + +// or: +const F: &C = &D; // error +``` + +This is because cell types do operations that are not thread-safe. Due to this, +they don't implement Sync and thus can't be placed in statics. + +However, if you still wish to use these types, you can achieve this by an unsafe +wrapper: + +``` +use std::cell::Cell; +use std::marker::Sync; + +struct NotThreadSafe<T> { + value: Cell<T>, +} + +unsafe impl<T> Sync for NotThreadSafe<T> {} + +static A: NotThreadSafe<usize> = NotThreadSafe { value : Cell::new(1) }; +static B: &'static NotThreadSafe<usize> = &A; // ok! +``` + +Remember this solution is unsafe! You will have to ensure that accesses to the +cell are synchronized. diff --git a/src/librustc_error_codes/error_codes/E0493.md b/src/librustc_error_codes/error_codes/E0493.md new file mode 100644 index 00000000000..90a0cbce623 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0493.md @@ -0,0 +1,42 @@ +A type with a `Drop` implementation was destructured when trying to initialize +a static item. + +Erroneous code example: + +```compile_fail,E0493 +enum DropType { + A, +} + +impl Drop for DropType { + fn drop(&mut self) {} +} + +struct Foo { + field1: DropType, +} + +static FOO: Foo = Foo { ..Foo { field1: DropType::A } }; // error! +``` + +The problem here is that if the given type or one of its fields implements the +`Drop` trait, this `Drop` implementation cannot be called during the static +type initialization which might cause a memory leak. To prevent this issue, +you need to instantiate all the static type's fields by hand. + +``` +enum DropType { + A, +} + +impl Drop for DropType { + fn drop(&mut self) {} +} + +struct Foo { + field1: DropType, +} + +static FOO: Foo = Foo { field1: DropType::A }; // We initialize all fields + // by hand. +``` diff --git a/src/librustc_error_codes/error_codes/E0495.md b/src/librustc_error_codes/error_codes/E0495.md new file mode 100644 index 00000000000..f956237b80b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0495.md @@ -0,0 +1,38 @@ +A lifetime cannot be determined in the given situation. + +Erroneous code example: + +```compile_fail,E0495 +fn transmute_lifetime<'a, 'b, T>(t: &'a (T,)) -> &'b T { + match (&t,) { // error! + ((u,),) => u, + } +} + +let y = Box::new((42,)); +let x = transmute_lifetime(&y); +``` + +In this code, you have two ways to solve this issue: + 1. Enforce that `'a` lives at least as long as `'b`. + 2. Use the same lifetime requirement for both input and output values. + +So for the first solution, you can do it by replacing `'a` with `'a: 'b`: + +``` +fn transmute_lifetime<'a: 'b, 'b, T>(t: &'a (T,)) -> &'b T { + match (&t,) { // ok! + ((u,),) => u, + } +} +``` + +In the second you can do it by simply removing `'b` so they both use `'a`: + +``` +fn transmute_lifetime<'a, T>(t: &'a (T,)) -> &'a T { + match (&t,) { // ok! + ((u,),) => u, + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0496.md b/src/librustc_error_codes/error_codes/E0496.md new file mode 100644 index 00000000000..83d65cd3e09 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0496.md @@ -0,0 +1,31 @@ +A lifetime name is shadowing another lifetime name. + +Erroneous code example: + +```compile_fail,E0496 +struct Foo<'a> { + a: &'a i32, +} + +impl<'a> Foo<'a> { + fn f<'a>(x: &'a i32) { // error: lifetime name `'a` shadows a lifetime + // name that is already in scope + } +} +``` + +Please change the name of one of the lifetimes to remove this error. Example: + +``` +struct Foo<'a> { + a: &'a i32, +} + +impl<'a> Foo<'a> { + fn f<'b>(x: &'b i32) { // ok! + } +} + +fn main() { +} +``` diff --git a/src/librustc_error_codes/error_codes/E0497.md b/src/librustc_error_codes/error_codes/E0497.md new file mode 100644 index 00000000000..ef2882415d2 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0497.md @@ -0,0 +1,14 @@ +#### Note: this error code is no longer emitted by the compiler. + +A stability attribute was used outside of the standard library. + +Erroneous code example: + +```compile_fail +#[stable] // error: stability attributes may not be used outside of the + // standard library +fn foo() {} +``` + +It is not possible to use stability attributes outside of the standard library. +Also, for now, it is not possible to write deprecation messages either. diff --git a/src/librustc_error_codes/error_codes/E0499.md b/src/librustc_error_codes/error_codes/E0499.md new file mode 100644 index 00000000000..370ceef530b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0499.md @@ -0,0 +1,30 @@ +A variable was borrowed as mutable more than once. + +Erroneous code example: + +```compile_fail,E0499 +let mut i = 0; +let mut x = &mut i; +let mut a = &mut i; +x; +// error: cannot borrow `i` as mutable more than once at a time +``` + +Please note that in rust, you can either have many immutable references, or one +mutable reference. Take a look at +https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html for more +information. Example: + + +``` +let mut i = 0; +let mut x = &mut i; // ok! + +// or: +let mut i = 0; +let a = &i; // ok! +let b = &i; // still ok! +let c = &i; // still ok! +b; +a; +``` diff --git a/src/librustc_error_codes/error_codes/E0500.md b/src/librustc_error_codes/error_codes/E0500.md new file mode 100644 index 00000000000..fde31d2c745 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0500.md @@ -0,0 +1,41 @@ +A borrowed variable was used by a closure. + +Erroneous code example: + +```compile_fail,E0500 +fn you_know_nothing(jon_snow: &mut i32) { + let nights_watch = &jon_snow; + let starks = || { + *jon_snow = 3; // error: closure requires unique access to `jon_snow` + // but it is already borrowed + }; + println!("{}", nights_watch); +} +``` + +In here, `jon_snow` is already borrowed by the `nights_watch` reference, so it +cannot be borrowed by the `starks` closure at the same time. To fix this issue, +you can create the closure after the borrow has ended: + +``` +fn you_know_nothing(jon_snow: &mut i32) { + let nights_watch = &jon_snow; + println!("{}", nights_watch); + let starks = || { + *jon_snow = 3; + }; +} +``` + +Or, if the type implements the `Clone` trait, you can clone it between +closures: + +``` +fn you_know_nothing(jon_snow: &mut i32) { + let mut jon_copy = jon_snow.clone(); + let starks = || { + *jon_snow = 3; + }; + println!("{}", jon_copy); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0501.md b/src/librustc_error_codes/error_codes/E0501.md new file mode 100644 index 00000000000..95e0dfd4001 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0501.md @@ -0,0 +1,76 @@ +This error indicates that a mutable variable is being used while it is still +captured by a closure. Because the closure has borrowed the variable, it is not +available for use until the closure goes out of scope. + +Note that a capture will either move or borrow a variable, but in this +situation, the closure is borrowing the variable. Take a look at +http://rustbyexample.com/fn/closures/capture.html for more information about +capturing. + +Erroneous code example: + +```compile_fail,E0501 +fn inside_closure(x: &mut i32) { + // Actions which require unique access +} + +fn outside_closure(x: &mut i32) { + // Actions which require unique access +} + +fn foo(a: &mut i32) { + let mut bar = || { + inside_closure(a) + }; + outside_closure(a); // error: cannot borrow `*a` as mutable because previous + // closure requires unique access. + bar(); +} +``` + +To fix this error, you can finish using the closure before using the captured +variable: + +``` +fn inside_closure(x: &mut i32) {} +fn outside_closure(x: &mut i32) {} + +fn foo(a: &mut i32) { + let mut bar = || { + inside_closure(a) + }; + bar(); + // borrow on `a` ends. + outside_closure(a); // ok! +} +``` + +Or you can pass the variable as a parameter to the closure: + +``` +fn inside_closure(x: &mut i32) {} +fn outside_closure(x: &mut i32) {} + +fn foo(a: &mut i32) { + let mut bar = |s: &mut i32| { + inside_closure(s) + }; + outside_closure(a); + bar(a); +} +``` + +It may be possible to define the closure later: + +``` +fn inside_closure(x: &mut i32) {} +fn outside_closure(x: &mut i32) {} + +fn foo(a: &mut i32) { + outside_closure(a); + let mut bar = || { + inside_closure(a) + }; + bar(); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0502.md b/src/librustc_error_codes/error_codes/E0502.md new file mode 100644 index 00000000000..69220259e3d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0502.md @@ -0,0 +1,29 @@ +This error indicates that you are trying to borrow a variable as mutable when it +has already been borrowed as immutable. + +Erroneous code example: + +```compile_fail,E0502 +fn bar(x: &mut i32) {} +fn foo(a: &mut i32) { + let ref y = a; // a is borrowed as immutable. + bar(a); // error: cannot borrow `*a` as mutable because `a` is also borrowed + // as immutable + println!("{}", y); +} +``` + +To fix this error, ensure that you don't have any other references to the +variable before trying to access it mutably: + +``` +fn bar(x: &mut i32) {} +fn foo(a: &mut i32) { + bar(a); + let ref y = a; // ok! + println!("{}", y); +} +``` + +For more information on the rust ownership system, take a look at +https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html. diff --git a/src/librustc_error_codes/error_codes/E0503.md b/src/librustc_error_codes/error_codes/E0503.md new file mode 100644 index 00000000000..c683619e3d0 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0503.md @@ -0,0 +1,52 @@ +A value was used after it was mutably borrowed. + +Erroneous code example: + +```compile_fail,E0503 +fn main() { + let mut value = 3; + // Create a mutable borrow of `value`. + let borrow = &mut value; + let _sum = value + 1; // error: cannot use `value` because + // it was mutably borrowed + println!("{}", borrow); +} +``` + +In this example, `value` is mutably borrowed by `borrow` and cannot be +used to calculate `sum`. This is not possible because this would violate +Rust's mutability rules. + +You can fix this error by finishing using the borrow before the next use of +the value: + +``` +fn main() { + let mut value = 3; + let borrow = &mut value; + println!("{}", borrow); + // The block has ended and with it the borrow. + // You can now use `value` again. + let _sum = value + 1; +} +``` + +Or by cloning `value` before borrowing it: + +``` +fn main() { + let mut value = 3; + // We clone `value`, creating a copy. + let value_cloned = value.clone(); + // The mutable borrow is a reference to `value` and + // not to `value_cloned`... + let borrow = &mut value; + // ... which means we can still use `value_cloned`, + let _sum = value_cloned + 1; + // even though the borrow only ends here. + println!("{}", borrow); +} +``` + +You can find more information about borrowing in the rust-book: +http://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html diff --git a/src/librustc_error_codes/error_codes/E0504.md b/src/librustc_error_codes/error_codes/E0504.md new file mode 100644 index 00000000000..bcbd00a8690 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0504.md @@ -0,0 +1,103 @@ +#### Note: this error code is no longer emitted by the compiler. + +This error occurs when an attempt is made to move a borrowed variable into a +closure. + +Erroneous code example: + +```compile_fail +struct FancyNum { + num: u8, +} + +fn main() { + let fancy_num = FancyNum { num: 5 }; + let fancy_ref = &fancy_num; + + let x = move || { + println!("child function: {}", fancy_num.num); + // error: cannot move `fancy_num` into closure because it is borrowed + }; + + x(); + println!("main function: {}", fancy_ref.num); +} +``` + +Here, `fancy_num` is borrowed by `fancy_ref` and so cannot be moved into +the closure `x`. There is no way to move a value into a closure while it is +borrowed, as that would invalidate the borrow. + +If the closure can't outlive the value being moved, try using a reference +rather than moving: + +``` +struct FancyNum { + num: u8, +} + +fn main() { + let fancy_num = FancyNum { num: 5 }; + let fancy_ref = &fancy_num; + + let x = move || { + // fancy_ref is usable here because it doesn't move `fancy_num` + println!("child function: {}", fancy_ref.num); + }; + + x(); + + println!("main function: {}", fancy_num.num); +} +``` + +If the value has to be borrowed and then moved, try limiting the lifetime of +the borrow using a scoped block: + +``` +struct FancyNum { + num: u8, +} + +fn main() { + let fancy_num = FancyNum { num: 5 }; + + { + let fancy_ref = &fancy_num; + println!("main function: {}", fancy_ref.num); + // `fancy_ref` goes out of scope here + } + + let x = move || { + // `fancy_num` can be moved now (no more references exist) + println!("child function: {}", fancy_num.num); + }; + + x(); +} +``` + +If the lifetime of a reference isn't enough, such as in the case of threading, +consider using an `Arc` to create a reference-counted value: + +``` +use std::sync::Arc; +use std::thread; + +struct FancyNum { + num: u8, +} + +fn main() { + let fancy_ref1 = Arc::new(FancyNum { num: 5 }); + let fancy_ref2 = fancy_ref1.clone(); + + let x = thread::spawn(move || { + // `fancy_ref1` can be moved and has a `'static` lifetime + println!("child thread: {}", fancy_ref1.num); + }); + + x.join().expect("child thread should finish"); + println!("main thread: {}", fancy_ref2.num); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0505.md b/src/librustc_error_codes/error_codes/E0505.md new file mode 100644 index 00000000000..14baa01cb50 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0505.md @@ -0,0 +1,85 @@ +A value was moved out while it was still borrowed. + +Erroneous code example: + +```compile_fail,E0505 +struct Value {} + +fn borrow(val: &Value) {} + +fn eat(val: Value) {} + +fn main() { + let x = Value{}; + let _ref_to_val: &Value = &x; + eat(x); + borrow(_ref_to_val); +} +``` + +Here, the function `eat` takes ownership of `x`. However, +`x` cannot be moved because the borrow to `_ref_to_val` +needs to last till the function `borrow`. +To fix that you can do a few different things: + +* Try to avoid moving the variable. +* Release borrow before move. +* Implement the `Copy` trait on the type. + +Examples: + +``` +struct Value {} + +fn borrow(val: &Value) {} + +fn eat(val: &Value) {} + +fn main() { + let x = Value{}; + + let ref_to_val: &Value = &x; + eat(&x); // pass by reference, if it's possible + borrow(ref_to_val); +} +``` + +Or: + +``` +struct Value {} + +fn borrow(val: &Value) {} + +fn eat(val: Value) {} + +fn main() { + let x = Value{}; + + let ref_to_val: &Value = &x; + borrow(ref_to_val); + // ref_to_val is no longer used. + eat(x); +} +``` + +Or: + +``` +#[derive(Clone, Copy)] // implement Copy trait +struct Value {} + +fn borrow(val: &Value) {} + +fn eat(val: Value) {} + +fn main() { + let x = Value{}; + let ref_to_val: &Value = &x; + eat(x); // it will be copied here. + borrow(ref_to_val); +} +``` + +You can find more information about borrowing in the rust-book: +http://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html diff --git a/src/librustc_error_codes/error_codes/E0506.md b/src/librustc_error_codes/error_codes/E0506.md new file mode 100644 index 00000000000..9b8e3164872 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0506.md @@ -0,0 +1,81 @@ +This error occurs when an attempt is made to assign to a borrowed value. + +Erroneous code example: + +```compile_fail,E0506 +struct FancyNum { + num: u8, +} + +fn main() { + let mut fancy_num = FancyNum { num: 5 }; + let fancy_ref = &fancy_num; + fancy_num = FancyNum { num: 6 }; + // error: cannot assign to `fancy_num` because it is borrowed + + println!("Num: {}, Ref: {}", fancy_num.num, fancy_ref.num); +} +``` + +Because `fancy_ref` still holds a reference to `fancy_num`, `fancy_num` can't +be assigned to a new value as it would invalidate the reference. + +Alternatively, we can move out of `fancy_num` into a second `fancy_num`: + +``` +struct FancyNum { + num: u8, +} + +fn main() { + let mut fancy_num = FancyNum { num: 5 }; + let moved_num = fancy_num; + fancy_num = FancyNum { num: 6 }; + + println!("Num: {}, Moved num: {}", fancy_num.num, moved_num.num); +} +``` + +If the value has to be borrowed, try limiting the lifetime of the borrow using +a scoped block: + +``` +struct FancyNum { + num: u8, +} + +fn main() { + let mut fancy_num = FancyNum { num: 5 }; + + { + let fancy_ref = &fancy_num; + println!("Ref: {}", fancy_ref.num); + } + + // Works because `fancy_ref` is no longer in scope + fancy_num = FancyNum { num: 6 }; + println!("Num: {}", fancy_num.num); +} +``` + +Or by moving the reference into a function: + +``` +struct FancyNum { + num: u8, +} + +fn main() { + let mut fancy_num = FancyNum { num: 5 }; + + print_fancy_ref(&fancy_num); + + // Works because function borrow has ended + fancy_num = FancyNum { num: 6 }; + println!("Num: {}", fancy_num.num); +} + +fn print_fancy_ref(fancy_ref: &FancyNum){ + println!("Ref: {}", fancy_ref.num); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0507.md b/src/librustc_error_codes/error_codes/E0507.md new file mode 100644 index 00000000000..89a6fb47377 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0507.md @@ -0,0 +1,131 @@ +You tried to move out of a value which was borrowed. + +This can also happen when using a type implementing `Fn` or `FnMut`, as neither +allows moving out of them (they usually represent closures which can be called +more than once). Much of the text following applies equally well to non-`FnOnce` +closure bodies. + +Erroneous code example: + +```compile_fail,E0507 +use std::cell::RefCell; + +struct TheDarkKnight; + +impl TheDarkKnight { + fn nothing_is_true(self) {} +} + +fn main() { + let x = RefCell::new(TheDarkKnight); + + x.borrow().nothing_is_true(); // error: cannot move out of borrowed content +} +``` + +Here, the `nothing_is_true` method takes the ownership of `self`. However, +`self` cannot be moved because `.borrow()` only provides an `&TheDarkKnight`, +which is a borrow of the content owned by the `RefCell`. To fix this error, +you have three choices: + +* Try to avoid moving the variable. +* Somehow reclaim the ownership. +* Implement the `Copy` trait on the type. + +Examples: + +``` +use std::cell::RefCell; + +struct TheDarkKnight; + +impl TheDarkKnight { + fn nothing_is_true(&self) {} // First case, we don't take ownership +} + +fn main() { + let x = RefCell::new(TheDarkKnight); + + x.borrow().nothing_is_true(); // ok! +} +``` + +Or: + +``` +use std::cell::RefCell; + +struct TheDarkKnight; + +impl TheDarkKnight { + fn nothing_is_true(self) {} +} + +fn main() { + let x = RefCell::new(TheDarkKnight); + let x = x.into_inner(); // we get back ownership + + x.nothing_is_true(); // ok! +} +``` + +Or: + +``` +use std::cell::RefCell; + +#[derive(Clone, Copy)] // we implement the Copy trait +struct TheDarkKnight; + +impl TheDarkKnight { + fn nothing_is_true(self) {} +} + +fn main() { + let x = RefCell::new(TheDarkKnight); + + x.borrow().nothing_is_true(); // ok! +} +``` + +Moving a member out of a mutably borrowed struct will also cause E0507 error: + +```compile_fail,E0507 +struct TheDarkKnight; + +impl TheDarkKnight { + fn nothing_is_true(self) {} +} + +struct Batcave { + knight: TheDarkKnight +} + +fn main() { + let mut cave = Batcave { + knight: TheDarkKnight + }; + let borrowed = &mut cave; + + borrowed.knight.nothing_is_true(); // E0507 +} +``` + +It is fine only if you put something back. `mem::replace` can be used for that: + +``` +# struct TheDarkKnight; +# impl TheDarkKnight { fn nothing_is_true(self) {} } +# struct Batcave { knight: TheDarkKnight } +use std::mem; + +let mut cave = Batcave { + knight: TheDarkKnight +}; +let borrowed = &mut cave; + +mem::replace(&mut borrowed.knight, TheDarkKnight).nothing_is_true(); // ok! +``` + +You can find more information about borrowing in the rust-book: +http://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html diff --git a/src/librustc_error_codes/error_codes/E0508.md b/src/librustc_error_codes/error_codes/E0508.md new file mode 100644 index 00000000000..33572fca6a3 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0508.md @@ -0,0 +1,41 @@ +A value was moved out of a non-copy fixed-size array. + +Erroneous code example: + +```compile_fail,E0508 +struct NonCopy; + +fn main() { + let array = [NonCopy; 1]; + let _value = array[0]; // error: cannot move out of type `[NonCopy; 1]`, + // a non-copy fixed-size array +} +``` + +The first element was moved out of the array, but this is not +possible because `NonCopy` does not implement the `Copy` trait. + +Consider borrowing the element instead of moving it: + +``` +struct NonCopy; + +fn main() { + let array = [NonCopy; 1]; + let _value = &array[0]; // Borrowing is allowed, unlike moving. +} +``` + +Alternatively, if your type implements `Clone` and you need to own the value, +consider borrowing and then cloning: + +``` +#[derive(Clone)] +struct NonCopy; + +fn main() { + let array = [NonCopy; 1]; + // Now you can clone the array element. + let _value = array[0].clone(); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0509.md b/src/librustc_error_codes/error_codes/E0509.md new file mode 100644 index 00000000000..9cbd7d695aa --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0509.md @@ -0,0 +1,92 @@ +This error occurs when an attempt is made to move out of a value whose type +implements the `Drop` trait. + +Erroneous code example: + +```compile_fail,E0509 +struct FancyNum { + num: usize +} + +struct DropStruct { + fancy: FancyNum +} + +impl Drop for DropStruct { + fn drop(&mut self) { + // Destruct DropStruct, possibly using FancyNum + } +} + +fn main() { + let drop_struct = DropStruct{fancy: FancyNum{num: 5}}; + let fancy_field = drop_struct.fancy; // Error E0509 + println!("Fancy: {}", fancy_field.num); + // implicit call to `drop_struct.drop()` as drop_struct goes out of scope +} +``` + +Here, we tried to move a field out of a struct of type `DropStruct` which +implements the `Drop` trait. However, a struct cannot be dropped if one or +more of its fields have been moved. + +Structs implementing the `Drop` trait have an implicit destructor that gets +called when they go out of scope. This destructor may use the fields of the +struct, so moving out of the struct could make it impossible to run the +destructor. Therefore, we must think of all values whose type implements the +`Drop` trait as single units whose fields cannot be moved. + +This error can be fixed by creating a reference to the fields of a struct, +enum, or tuple using the `ref` keyword: + +``` +struct FancyNum { + num: usize +} + +struct DropStruct { + fancy: FancyNum +} + +impl Drop for DropStruct { + fn drop(&mut self) { + // Destruct DropStruct, possibly using FancyNum + } +} + +fn main() { + let drop_struct = DropStruct{fancy: FancyNum{num: 5}}; + let ref fancy_field = drop_struct.fancy; // No more errors! + println!("Fancy: {}", fancy_field.num); + // implicit call to `drop_struct.drop()` as drop_struct goes out of scope +} +``` + +Note that this technique can also be used in the arms of a match expression: + +``` +struct FancyNum { + num: usize +} + +enum DropEnum { + Fancy(FancyNum) +} + +impl Drop for DropEnum { + fn drop(&mut self) { + // Destruct DropEnum, possibly using FancyNum + } +} + +fn main() { + // Creates and enum of type `DropEnum`, which implements `Drop` + let drop_enum = DropEnum::Fancy(FancyNum{num: 10}); + match drop_enum { + // Creates a reference to the inside of `DropEnum::Fancy` + DropEnum::Fancy(ref fancy_field) => // No error! + println!("It was fancy-- {}!", fancy_field.num), + } + // implicit call to `drop_enum.drop()` as drop_enum goes out of scope +} +``` diff --git a/src/librustc_error_codes/error_codes/E0510.md b/src/librustc_error_codes/error_codes/E0510.md new file mode 100644 index 00000000000..d5be417888b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0510.md @@ -0,0 +1,16 @@ +Cannot mutate place in this match guard. + +When matching on a variable it cannot be mutated in the match guards, as this +could cause the match to be non-exhaustive: + +```compile_fail,E0510 +let mut x = Some(0); +match x { + None => (), + Some(_) if { x = None; false } => (), + Some(v) => (), // No longer matches +} +``` + +Here executing `x = None` would modify the value being matched and require us +to go "back in time" to the `None` arm. diff --git a/src/librustc_error_codes/error_codes/E0511.md b/src/librustc_error_codes/error_codes/E0511.md new file mode 100644 index 00000000000..2d6ff8241e6 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0511.md @@ -0,0 +1,32 @@ +Invalid monomorphization of an intrinsic function was used. Erroneous code +example: + +```ignore (error-emitted-at-codegen-which-cannot-be-handled-by-compile_fail) +#![feature(platform_intrinsics)] + +extern "platform-intrinsic" { + fn simd_add<T>(a: T, b: T) -> T; +} + +fn main() { + unsafe { simd_add(0, 1); } + // error: invalid monomorphization of `simd_add` intrinsic +} +``` + +The generic type has to be a SIMD type. Example: + +``` +#![feature(repr_simd)] +#![feature(platform_intrinsics)] + +#[repr(simd)] +#[derive(Copy, Clone)] +struct i32x2(i32, i32); + +extern "platform-intrinsic" { + fn simd_add<T>(a: T, b: T) -> T; +} + +unsafe { simd_add(i32x2(0, 0), i32x2(1, 2)); } // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0512.md b/src/librustc_error_codes/error_codes/E0512.md new file mode 100644 index 00000000000..c13c0511c75 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0512.md @@ -0,0 +1,24 @@ +Transmute with two differently sized types was attempted. Erroneous code +example: + +```compile_fail,E0512 +fn takes_u8(_: u8) {} + +fn main() { + unsafe { takes_u8(::std::mem::transmute(0u16)); } + // error: cannot transmute between types of different sizes, + // or dependently-sized types +} +``` + +Please use types with same size or use the expected type directly. Example: + +``` +fn takes_u8(_: u8) {} + +fn main() { + unsafe { takes_u8(::std::mem::transmute(0i8)); } // ok! + // or: + unsafe { takes_u8(0u8); } // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0515.md b/src/librustc_error_codes/error_codes/E0515.md new file mode 100644 index 00000000000..9580b6f92ac --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0515.md @@ -0,0 +1,37 @@ +Cannot return value that references local variable + +Local variables, function parameters and temporaries are all dropped before the +end of the function body. So a reference to them cannot be returned. + +Erroneous code example: + +```compile_fail,E0515 +fn get_dangling_reference() -> &'static i32 { + let x = 0; + &x +} +``` + +```compile_fail,E0515 +use std::slice::Iter; +fn get_dangling_iterator<'a>() -> Iter<'a, i32> { + let v = vec![1, 2, 3]; + v.iter() +} +``` + +Consider returning an owned value instead: + +``` +use std::vec::IntoIter; + +fn get_integer() -> i32 { + let x = 0; + x +} + +fn get_owned_iterator() -> IntoIter<i32> { + let v = vec![1, 2, 3]; + v.into_iter() +} +``` diff --git a/src/librustc_error_codes/error_codes/E0516.md b/src/librustc_error_codes/error_codes/E0516.md new file mode 100644 index 00000000000..815d7609013 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0516.md @@ -0,0 +1,16 @@ +The `typeof` keyword is currently reserved but unimplemented. +Erroneous code example: + +```compile_fail,E0516 +fn main() { + let x: typeof(92) = 92; +} +``` + +Try using type inference instead. Example: + +``` +fn main() { + let x = 92; +} +``` diff --git a/src/librustc_error_codes/error_codes/E0517.md b/src/librustc_error_codes/error_codes/E0517.md new file mode 100644 index 00000000000..f738d33560a --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0517.md @@ -0,0 +1,45 @@ +This error indicates that a `#[repr(..)]` attribute was placed on an +unsupported item. + +Examples of erroneous code: + +```compile_fail,E0517 +#[repr(C)] +type Foo = u8; + +#[repr(packed)] +enum Foo {Bar, Baz} + +#[repr(u8)] +struct Foo {bar: bool, baz: bool} + +#[repr(C)] +impl Foo { + // ... +} +``` + +* The `#[repr(C)]` attribute can only be placed on structs and enums. +* The `#[repr(packed)]` and `#[repr(simd)]` attributes only work on structs. +* The `#[repr(u8)]`, `#[repr(i16)]`, etc attributes only work on enums. + +These attributes do not work on typedefs, since typedefs are just aliases. + +Representations like `#[repr(u8)]`, `#[repr(i64)]` are for selecting the +discriminant size for enums with no data fields on any of the variants, e.g. +`enum Color {Red, Blue, Green}`, effectively setting the size of the enum to +the size of the provided type. Such an enum can be cast to a value of the same +type as well. In short, `#[repr(u8)]` makes the enum behave like an integer +with a constrained set of allowed values. + +Only field-less enums can be cast to numerical primitives, so this attribute +will not apply to structs. + +`#[repr(packed)]` reduces padding to make the struct size smaller. The +representation of enums isn't strictly defined in Rust, and this attribute +won't work on enums. + +`#[repr(simd)]` will give a struct consisting of a homogeneous series of machine +types (i.e., `u8`, `i32`, etc) a representation that permits vectorization via +SIMD. This doesn't make much sense for enums since they don't consist of a +single list of data. diff --git a/src/librustc_error_codes/error_codes/E0518.md b/src/librustc_error_codes/error_codes/E0518.md new file mode 100644 index 00000000000..1af9a3735fe --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0518.md @@ -0,0 +1,23 @@ +This error indicates that an `#[inline(..)]` attribute was incorrectly placed +on something other than a function or method. + +Examples of erroneous code: + +```compile_fail,E0518 +#[inline(always)] +struct Foo; + +#[inline(never)] +impl Foo { + // ... +} +``` + +`#[inline]` hints the compiler whether or not to attempt to inline a method or +function. By default, the compiler does a pretty good job of figuring this out +itself, but if you feel the need for annotations, `#[inline(always)]` and +`#[inline(never)]` can override or force the compiler's decision. + +If you wish to apply this attribute to all methods in an impl, manually annotate +each method; it is not possible to annotate the entire impl with an `#[inline]` +attribute. diff --git a/src/librustc_error_codes/error_codes/E0520.md b/src/librustc_error_codes/error_codes/E0520.md new file mode 100644 index 00000000000..e8a2b4da080 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0520.md @@ -0,0 +1,59 @@ +A non-default implementation was already made on this type so it cannot be +specialized further. Erroneous code example: + +```compile_fail,E0520 +#![feature(specialization)] + +trait SpaceLlama { + fn fly(&self); +} + +// applies to all T +impl<T> SpaceLlama for T { + default fn fly(&self) {} +} + +// non-default impl +// applies to all `Clone` T and overrides the previous impl +impl<T: Clone> SpaceLlama for T { + fn fly(&self) {} +} + +// since `i32` is clone, this conflicts with the previous implementation +impl SpaceLlama for i32 { + default fn fly(&self) {} + // error: item `fly` is provided by an `impl` that specializes + // another, but the item in the parent `impl` is not marked + // `default` and so it cannot be specialized. +} +``` + +Specialization only allows you to override `default` functions in +implementations. + +To fix this error, you need to mark all the parent implementations as default. +Example: + +``` +#![feature(specialization)] + +trait SpaceLlama { + fn fly(&self); +} + +// applies to all T +impl<T> SpaceLlama for T { + default fn fly(&self) {} // This is a parent implementation. +} + +// applies to all `Clone` T; overrides the previous impl +impl<T: Clone> SpaceLlama for T { + default fn fly(&self) {} // This is a parent implementation but was + // previously not a default one, causing the error +} + +// applies to i32, overrides the previous two impls +impl SpaceLlama for i32 { + fn fly(&self) {} // And now that's ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0522.md b/src/librustc_error_codes/error_codes/E0522.md new file mode 100644 index 00000000000..e4756c384c4 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0522.md @@ -0,0 +1,14 @@ +The lang attribute is intended for marking special items that are built-in to +Rust itself. This includes special traits (like `Copy` and `Sized`) that affect +how the compiler behaves, as well as special functions that may be automatically +invoked (such as the handler for out-of-bounds accesses when indexing a slice). +Erroneous code example: + +```compile_fail,E0522 +#![feature(lang_items)] + +#[lang = "cookie"] +fn cookie() -> ! { // error: definition of an unknown language item: `cookie` + loop {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0524.md b/src/librustc_error_codes/error_codes/E0524.md new file mode 100644 index 00000000000..bab241b5a95 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0524.md @@ -0,0 +1,60 @@ +A variable which requires unique access is being used in more than one closure +at the same time. + +Erroneous code example: + +```compile_fail,E0524 +fn set(x: &mut isize) { + *x += 4; +} + +fn dragoooon(x: &mut isize) { + let mut c1 = || set(x); + let mut c2 = || set(x); // error! + + c2(); + c1(); +} +``` + +To solve this issue, multiple solutions are available. First, is it required +for this variable to be used in more than one closure at a time? If it is the +case, use reference counted types such as `Rc` (or `Arc` if it runs +concurrently): + +``` +use std::rc::Rc; +use std::cell::RefCell; + +fn set(x: &mut isize) { + *x += 4; +} + +fn dragoooon(x: &mut isize) { + let x = Rc::new(RefCell::new(x)); + let y = Rc::clone(&x); + let mut c1 = || { let mut x2 = x.borrow_mut(); set(&mut x2); }; + let mut c2 = || { let mut x2 = y.borrow_mut(); set(&mut x2); }; // ok! + + c2(); + c1(); +} +``` + +If not, just run closures one at a time: + +``` +fn set(x: &mut isize) { + *x += 4; +} + +fn dragoooon(x: &mut isize) { + { // This block isn't necessary since non-lexical lifetimes, it's just to + // make it more clear. + let mut c1 = || set(&mut *x); + c1(); + } // `c1` has been dropped here so we're free to use `x` again! + let mut c2 = || set(&mut *x); + c2(); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0525.md b/src/librustc_error_codes/error_codes/E0525.md new file mode 100644 index 00000000000..95e5f362bde --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0525.md @@ -0,0 +1,40 @@ +A closure was used but didn't implement the expected trait. + +Erroneous code example: + +```compile_fail,E0525 +struct X; + +fn foo<T>(_: T) {} +fn bar<T: Fn(u32)>(_: T) {} + +fn main() { + let x = X; + let closure = |_| foo(x); // error: expected a closure that implements + // the `Fn` trait, but this closure only + // implements `FnOnce` + bar(closure); +} +``` + +In the example above, `closure` is an `FnOnce` closure whereas the `bar` +function expected an `Fn` closure. In this case, it's simple to fix the issue, +you just have to implement `Copy` and `Clone` traits on `struct X` and it'll +be ok: + +``` +#[derive(Clone, Copy)] // We implement `Clone` and `Copy` traits. +struct X; + +fn foo<T>(_: T) {} +fn bar<T: Fn(u32)>(_: T) {} + +fn main() { + let x = X; + let closure = |_| foo(x); + bar(closure); // ok! +} +``` + +To understand better how closures work in Rust, read: +https://doc.rust-lang.org/book/ch13-01-closures.html diff --git a/src/librustc_error_codes/error_codes/E0527.md b/src/librustc_error_codes/error_codes/E0527.md new file mode 100644 index 00000000000..4bff39dc770 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0527.md @@ -0,0 +1,28 @@ +The number of elements in an array or slice pattern differed from the number of +elements in the array being matched. + +Example of erroneous code: + +```compile_fail,E0527 +let r = &[1, 2, 3, 4]; +match r { + &[a, b] => { // error: pattern requires 2 elements but array + // has 4 + println!("a={}, b={}", a, b); + } +} +``` + +Ensure that the pattern is consistent with the size of the matched +array. Additional elements can be matched with `..`: + +``` +#![feature(slice_patterns)] + +let r = &[1, 2, 3, 4]; +match r { + &[a, b, ..] => { // ok! + println!("a={}, b={}", a, b); + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0528.md b/src/librustc_error_codes/error_codes/E0528.md new file mode 100644 index 00000000000..4b6ea246991 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0528.md @@ -0,0 +1,31 @@ +An array or slice pattern required more elements than were present in the +matched array. + +Example of erroneous code: + +```compile_fail,E0528 +#![feature(slice_patterns)] + +let r = &[1, 2]; +match r { + &[a, b, c, rest @ ..] => { // error: pattern requires at least 3 + // elements but array has 2 + println!("a={}, b={}, c={} rest={:?}", a, b, c, rest); + } +} +``` + +Ensure that the matched array has at least as many elements as the pattern +requires. You can match an arbitrary number of remaining elements with `..`: + +``` +#![feature(slice_patterns)] + +let r = &[1, 2, 3, 4, 5]; +match r { + &[a, b, c, rest @ ..] => { // ok! + // prints `a=1, b=2, c=3 rest=[4, 5]` + println!("a={}, b={}, c={} rest={:?}", a, b, c, rest); + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0529.md b/src/librustc_error_codes/error_codes/E0529.md new file mode 100644 index 00000000000..013f438ba93 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0529.md @@ -0,0 +1,24 @@ +An array or slice pattern was matched against some other type. + +Example of erroneous code: + +```compile_fail,E0529 +let r: f32 = 1.0; +match r { + [a, b] => { // error: expected an array or slice, found `f32` + println!("a={}, b={}", a, b); + } +} +``` + +Ensure that the pattern and the expression being matched on are of consistent +types: + +``` +let r = [1.0, 2.0]; +match r { + [a, b] => { // ok! + println!("a={}, b={}", a, b); + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0530.md b/src/librustc_error_codes/error_codes/E0530.md new file mode 100644 index 00000000000..502f674fc1d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0530.md @@ -0,0 +1,32 @@ +A binding shadowed something it shouldn't. + +Erroneous code example: + +```compile_fail,E0530 +static TEST: i32 = 0; + +let r: (i32, i32) = (0, 0); +match r { + TEST => {} // error: match bindings cannot shadow statics +} +``` + +To fix this error, just change the binding's name in order to avoid shadowing +one of the following: + +* struct name +* struct/enum variant +* static +* const +* associated const + +Fixed example: + +``` +static TEST: i32 = 0; + +let r: (i32, i32) = (0, 0); +match r { + something => {} // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0531.md b/src/librustc_error_codes/error_codes/E0531.md new file mode 100644 index 00000000000..2814046fbdd --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0531.md @@ -0,0 +1,42 @@ +An unknown tuple struct/variant has been used. + +Erroneous code example: + +```compile_fail,E0531 +let Type(x) = Type(12); // error! +match Bar(12) { + Bar(x) => {} // error! + _ => {} +} +``` + +In most cases, it's either a forgotten import or a typo. However, let's look at +how you can have such a type: + +```edition2018 +struct Type(u32); // this is a tuple struct + +enum Foo { + Bar(u32), // this is a tuple variant +} + +use Foo::*; // To use Foo's variant directly, we need to import them in + // the scope. +``` + +Either way, it should work fine with our previous code: + +```edition2018 +struct Type(u32); + +enum Foo { + Bar(u32), +} +use Foo::*; + +let Type(x) = Type(12); // ok! +match Type(12) { + Type(x) => {} // ok! + _ => {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0532.md b/src/librustc_error_codes/error_codes/E0532.md new file mode 100644 index 00000000000..6fb315a3716 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0532.md @@ -0,0 +1,38 @@ +Pattern arm did not match expected kind. + +Erroneous code example: + +```compile_fail,E0532 +enum State { + Succeeded, + Failed(String), +} + +fn print_on_failure(state: &State) { + match *state { + // error: expected unit struct, unit variant or constant, found tuple + // variant `State::Failed` + State::Failed => println!("Failed"), + _ => () + } +} +``` + +To fix this error, ensure the match arm kind is the same as the expression +matched. + +Fixed example: + +``` +enum State { + Succeeded, + Failed(String), +} + +fn print_on_failure(state: &State) { + match *state { + State::Failed(ref msg) => println!("Failed with {}", msg), + _ => () + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0533.md b/src/librustc_error_codes/error_codes/E0533.md new file mode 100644 index 00000000000..279d728caae --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0533.md @@ -0,0 +1,34 @@ +An item which isn't a unit struct, a variant, nor a constant has been used as a +match pattern. + +Erroneous code example: + +```compile_fail,E0533 +struct Tortoise; + +impl Tortoise { + fn turtle(&self) -> u32 { 0 } +} + +match 0u32 { + Tortoise::turtle => {} // Error! + _ => {} +} +if let Tortoise::turtle = 0u32 {} // Same error! +``` + +If you want to match against a value returned by a method, you need to bind the +value first: + +``` +struct Tortoise; + +impl Tortoise { + fn turtle(&self) -> u32 { 0 } +} + +match 0u32 { + x if x == Tortoise.turtle() => {} // Bound into `x` then we compare it! + _ => {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0534.md b/src/librustc_error_codes/error_codes/E0534.md new file mode 100644 index 00000000000..e50b84764b4 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0534.md @@ -0,0 +1,35 @@ +The `inline` attribute was malformed. + +Erroneous code example: + +```ignore (compile_fail not working here; see Issue #43707) +#[inline()] // error: expected one argument +pub fn something() {} + +fn main() {} +``` + +The parenthesized `inline` attribute requires the parameter to be specified: + +``` +#[inline(always)] +fn something() {} +``` + +or: + +``` +#[inline(never)] +fn something() {} +``` + +Alternatively, a paren-less version of the attribute may be used to hint the +compiler about inlining opportunity: + +``` +#[inline] +fn something() {} +``` + +For more information about the inline attribute, read: +https://doc.rust-lang.org/reference.html#inline-attributes diff --git a/src/librustc_error_codes/error_codes/E0535.md b/src/librustc_error_codes/error_codes/E0535.md new file mode 100644 index 00000000000..e9abfe5dda1 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0535.md @@ -0,0 +1,28 @@ +An unknown argument was given to the `inline` attribute. + +Erroneous code example: + +```ignore (compile_fail not working here; see Issue #43707) +#[inline(unknown)] // error: invalid argument +pub fn something() {} + +fn main() {} +``` + +The `inline` attribute only supports two arguments: + + * always + * never + +All other arguments given to the `inline` attribute will return this error. +Example: + +``` +#[inline(never)] // ok! +pub fn something() {} + +fn main() {} +``` + +For more information about the inline attribute, https: +read://doc.rust-lang.org/reference.html#inline-attributes diff --git a/src/librustc_error_codes/error_codes/E0536.md b/src/librustc_error_codes/error_codes/E0536.md new file mode 100644 index 00000000000..9006906a703 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0536.md @@ -0,0 +1,22 @@ +The `not` cfg-predicate was malformed. + +Erroneous code example: + +```compile_fail,E0536 +#[cfg(not())] // error: expected 1 cfg-pattern +pub fn something() {} + +pub fn main() {} +``` + +The `not` predicate expects one cfg-pattern. Example: + +``` +#[cfg(not(target_os = "linux"))] // ok! +pub fn something() {} + +pub fn main() {} +``` + +For more information about the cfg attribute, read: +https://doc.rust-lang.org/reference.html#conditional-compilation diff --git a/src/librustc_error_codes/error_codes/E0537.md b/src/librustc_error_codes/error_codes/E0537.md new file mode 100644 index 00000000000..82d8c6188af --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0537.md @@ -0,0 +1,28 @@ +An unknown predicate was used inside the `cfg` attribute. + +Erroneous code example: + +```compile_fail,E0537 +#[cfg(unknown())] // error: invalid predicate `unknown` +pub fn something() {} + +pub fn main() {} +``` + +The `cfg` attribute supports only three kinds of predicates: + + * any + * all + * not + +Example: + +``` +#[cfg(not(target_os = "linux"))] // ok! +pub fn something() {} + +pub fn main() {} +``` + +For more information about the cfg attribute, read: +https://doc.rust-lang.org/reference.html#conditional-compilation diff --git a/src/librustc_error_codes/error_codes/E0538.md b/src/librustc_error_codes/error_codes/E0538.md new file mode 100644 index 00000000000..5858771ce88 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0538.md @@ -0,0 +1,27 @@ +Attribute contains same meta item more than once. + +Erroneous code example: + +```compile_fail,E0538 +#[deprecated( + since="1.0.0", + note="First deprecation note.", + note="Second deprecation note." // error: multiple same meta item +)] +fn deprecated_function() {} +``` + +Meta items are the key-value pairs inside of an attribute. Each key may only be +used once in each attribute. + +To fix the problem, remove all but one of the meta items with the same key. + +Example: + +``` +#[deprecated( + since="1.0.0", + note="First deprecation note." +)] +fn deprecated_function() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0541.md b/src/librustc_error_codes/error_codes/E0541.md new file mode 100644 index 00000000000..96334088fee --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0541.md @@ -0,0 +1,29 @@ +An unknown meta item was used. + +Erroneous code example: + +```compile_fail,E0541 +#[deprecated( + since="1.0.0", + // error: unknown meta item + reason="Example invalid meta item. Should be 'note'") +] +fn deprecated_function() {} +``` + +Meta items are the key-value pairs inside of an attribute. The keys provided +must be one of the valid keys for the specified attribute. + +To fix the problem, either remove the unknown meta item, or rename it if you +provided the wrong name. + +In the erroneous code example above, the wrong name was provided, so changing +to a correct one it will fix the error. Example: + +``` +#[deprecated( + since="1.0.0", + note="This is a valid meta item for the deprecated attribute." +)] +fn deprecated_function() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0550.md b/src/librustc_error_codes/error_codes/E0550.md new file mode 100644 index 00000000000..1487d701847 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0550.md @@ -0,0 +1,16 @@ +More than one `deprecated` attribute has been put on an item. + +Erroneous code example: + +```compile_fail,E0550 +#[deprecated(note = "because why not?")] +#[deprecated(note = "right?")] // error! +fn the_banished() {} +``` + +The `deprecated` attribute can only be present **once** on an item. + +``` +#[deprecated(note = "because why not, right?")] +fn the_banished() {} // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0551.md b/src/librustc_error_codes/error_codes/E0551.md new file mode 100644 index 00000000000..53db559a4fc --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0551.md @@ -0,0 +1,16 @@ +An invalid meta-item was used inside an attribute. + +Erroneous code example: + +```compile_fail,E0551 +#[deprecated(note)] // error! +fn i_am_deprecated() {} +``` + +Meta items are the key-value pairs inside of an attribute. To fix this issue, +you need to give a value to the `note` key. Example: + +``` +#[deprecated(note = "because")] // ok! +fn i_am_deprecated() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0552.md b/src/librustc_error_codes/error_codes/E0552.md new file mode 100644 index 00000000000..0fbc861fb7c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0552.md @@ -0,0 +1,27 @@ +A unrecognized representation attribute was used. + +Erroneous code example: + +```compile_fail,E0552 +#[repr(D)] // error: unrecognized representation hint +struct MyStruct { + my_field: usize +} +``` + +You can use a `repr` attribute to tell the compiler how you want a struct or +enum to be laid out in memory. + +Make sure you're using one of the supported options: + +``` +#[repr(C)] // ok! +struct MyStruct { + my_field: usize +} +``` + +For more information about specifying representations, see the ["Alternative +Representations" section] of the Rustonomicon. + +["Alternative Representations" section]: https://doc.rust-lang.org/nomicon/other-reprs.html diff --git a/src/librustc_error_codes/error_codes/E0554.md b/src/librustc_error_codes/error_codes/E0554.md new file mode 100644 index 00000000000..e25212983eb --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0554.md @@ -0,0 +1,12 @@ +Feature attributes are only allowed on the nightly release channel. Stable or +beta compilers will not comply. + +Example of erroneous code (on a stable compiler): + +```ignore (depends on release channel) +#![feature(non_ascii_idents)] // error: `#![feature]` may not be used on the + // stable release channel +``` + +If you need the feature, make sure to use a nightly release of the compiler +(but be warned that the feature may be removed or altered in the future). diff --git a/src/librustc_error_codes/error_codes/E0556.md b/src/librustc_error_codes/error_codes/E0556.md new file mode 100644 index 00000000000..2aac8240d29 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0556.md @@ -0,0 +1,16 @@ +The `feature` attribute was badly formed. + +Erroneous code example: + +```compile_fail,E0556 +#![feature(foo_bar_baz, foo(bar), foo = "baz", foo)] // error! +#![feature] // error! +#![feature = "foo"] // error! +``` + +The `feature` attribute only accept a "feature flag" and can only be used on +nightly. Example: + +```ignore (only works in nightly) +#![feature(flag)] +``` diff --git a/src/librustc_error_codes/error_codes/E0557.md b/src/librustc_error_codes/error_codes/E0557.md new file mode 100644 index 00000000000..f330efe5933 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0557.md @@ -0,0 +1,9 @@ +A feature attribute named a feature that has been removed. + +Erroneous code example: + +```compile_fail,E0557 +#![feature(managed_boxes)] // error: feature has been removed +``` + +Delete the offending feature attribute. diff --git a/src/librustc_error_codes/error_codes/E0559.md b/src/librustc_error_codes/error_codes/E0559.md new file mode 100644 index 00000000000..b9f7b650892 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0559.md @@ -0,0 +1,22 @@ +An unknown field was specified into an enum's structure variant. + +Erroneous code example: + +```compile_fail,E0559 +enum Field { + Fool { x: u32 }, +} + +let s = Field::Fool { joke: 0 }; +// error: struct variant `Field::Fool` has no field named `joke` +``` + +Verify you didn't misspell the field's name or that the field exists. Example: + +``` +enum Field { + Fool { joke: u32 }, +} + +let s = Field::Fool { joke: 0 }; // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0560.md b/src/librustc_error_codes/error_codes/E0560.md new file mode 100644 index 00000000000..7185bf38c23 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0560.md @@ -0,0 +1,23 @@ +An unknown field was specified into a structure. + +Erroneous code example: + +```compile_fail,E0560 +struct Simba { + mother: u32, +} + +let s = Simba { mother: 1, father: 0 }; +// error: structure `Simba` has no field named `father` +``` + +Verify you didn't misspell the field's name or that the field exists. Example: + +``` +struct Simba { + mother: u32, + father: u32, +} + +let s = Simba { mother: 1, father: 0 }; // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0561.md b/src/librustc_error_codes/error_codes/E0561.md new file mode 100644 index 00000000000..52900189014 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0561.md @@ -0,0 +1,25 @@ +A non-ident or non-wildcard pattern has been used as a parameter of a function +pointer type. + +Erroneous code example: + +```compile_fail,E0561 +type A1 = fn(mut param: u8); // error! +type A2 = fn(¶m: u32); // error! +``` + +When using an alias over a function type, you cannot e.g. denote a parameter as +being mutable. + +To fix the issue, remove patterns (`_` is allowed though). Example: + +``` +type A1 = fn(param: u8); // ok! +type A2 = fn(_: u32); // ok! +``` + +You can also omit the parameter name: + +``` +type A3 = fn(i16); // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0562.md b/src/librustc_error_codes/error_codes/E0562.md new file mode 100644 index 00000000000..95f038df56d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0562.md @@ -0,0 +1,33 @@ +Abstract return types (written `impl Trait` for some trait `Trait`) are only +allowed as function and inherent impl return types. + +Erroneous code example: + +```compile_fail,E0562 +fn main() { + let count_to_ten: impl Iterator<Item=usize> = 0..10; + // error: `impl Trait` not allowed outside of function and inherent method + // return types + for i in count_to_ten { + println!("{}", i); + } +} +``` + +Make sure `impl Trait` only appears in return-type position. + +``` +fn count_to_n(n: usize) -> impl Iterator<Item=usize> { + 0..n +} + +fn main() { + for i in count_to_n(10) { // ok! + println!("{}", i); + } +} +``` + +See [RFC 1522] for more details. + +[RFC 1522]: https://github.com/rust-lang/rfcs/blob/master/text/1522-conservative-impl-trait.md diff --git a/src/librustc_error_codes/error_codes/E0565.md b/src/librustc_error_codes/error_codes/E0565.md new file mode 100644 index 00000000000..1faedf45932 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0565.md @@ -0,0 +1,17 @@ +A literal was used in a built-in attribute that doesn't support literals. + +Erroneous code example: + +```ignore (compile_fail not working here; see Issue #43707) +#[inline("always")] // error: unsupported literal +pub fn something() {} +``` + +Literals in attributes are new and largely unsupported in built-in attributes. +Work to support literals where appropriate is ongoing. Try using an unquoted +name instead: + +``` +#[inline(always)] +pub fn something() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0566.md b/src/librustc_error_codes/error_codes/E0566.md new file mode 100644 index 00000000000..62fb66f6149 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0566.md @@ -0,0 +1,18 @@ +Conflicting representation hints have been used on a same item. + +Erroneous code example: + +``` +#[repr(u32, u64)] // warning! +enum Repr { A } +``` + +In most cases (if not all), using just one representation hint is more than +enough. If you want to have a representation hint depending on the current +architecture, use `cfg_attr`. Example: + +``` +#[cfg_attr(linux, repr(u32))] +#[cfg_attr(not(linux), repr(u64))] +enum Repr { A } +``` diff --git a/src/librustc_error_codes/error_codes/E0567.md b/src/librustc_error_codes/error_codes/E0567.md new file mode 100644 index 00000000000..ec1ed03c126 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0567.md @@ -0,0 +1,25 @@ +Generics have been used on an auto trait. + +Erroneous code example: + +```compile_fail,E0567 +#![feature(optin_builtin_traits)] + +auto trait Generic<T> {} // error! + +fn main() {} +``` + +Since an auto trait is implemented on all existing types, the +compiler would not be able to infer the types of the trait's generic +parameters. + +To fix this issue, just remove the generics: + +``` +#![feature(optin_builtin_traits)] + +auto trait Generic {} // ok! + +fn main() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0568.md b/src/librustc_error_codes/error_codes/E0568.md new file mode 100644 index 00000000000..a37381f1cbd --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0568.md @@ -0,0 +1,26 @@ +A super trait has been added to an auto trait. + +Erroneous code example: + +```compile_fail,E0568 +#![feature(optin_builtin_traits)] + +auto trait Bound : Copy {} // error! + +fn main() {} +``` + +Since an auto trait is implemented on all existing types, adding a super trait +would filter out a lot of those types. In the current example, almost none of +all the existing types could implement `Bound` because very few of them have the +`Copy` trait. + +To fix this issue, just remove the super trait: + +``` +#![feature(optin_builtin_traits)] + +auto trait Bound {} // ok! + +fn main() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0569.md b/src/librustc_error_codes/error_codes/E0569.md new file mode 100644 index 00000000000..4cba0cf9c96 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0569.md @@ -0,0 +1,18 @@ +If an impl has a generic parameter with the `#[may_dangle]` attribute, then +that impl must be declared as an `unsafe impl. + +Erroneous code example: + +```compile_fail,E0569 +#![feature(dropck_eyepatch)] + +struct Foo<X>(X); +impl<#[may_dangle] X> Drop for Foo<X> { + fn drop(&mut self) { } +} +``` + +In this example, we are asserting that the destructor for `Foo` will not +access any data of type `X`, and require this assertion to be true for +overall safety in our program. The compiler does not currently attempt to +verify this assertion; therefore we must tag this `impl` as unsafe. diff --git a/src/librustc_error_codes/error_codes/E0570.md b/src/librustc_error_codes/error_codes/E0570.md new file mode 100644 index 00000000000..bf9615f8738 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0570.md @@ -0,0 +1,7 @@ +The requested ABI is unsupported by the current target. + +The rust compiler maintains for each target a blacklist of ABIs unsupported on +that target. If an ABI is present in such a list this usually means that the +target / ABI combination is currently unsupported by llvm. + +If necessary, you can circumvent this check using custom target specifications. diff --git a/src/librustc_error_codes/error_codes/E0571.md b/src/librustc_error_codes/error_codes/E0571.md new file mode 100644 index 00000000000..c2a3a8d7588 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0571.md @@ -0,0 +1,31 @@ +A `break` statement with an argument appeared in a non-`loop` loop. + +Example of erroneous code: + +```compile_fail,E0571 +# let mut i = 1; +# fn satisfied(n: usize) -> bool { n % 23 == 0 } +let result = while true { + if satisfied(i) { + break 2*i; // error: `break` with value from a `while` loop + } + i += 1; +}; +``` + +The `break` statement can take an argument (which will be the value of the loop +expression if the `break` statement is executed) in `loop` loops, but not +`for`, `while`, or `while let` loops. + +Make sure `break value;` statements only occur in `loop` loops: + +``` +# let mut i = 1; +# fn satisfied(n: usize) -> bool { n % 23 == 0 } +let result = loop { // ok! + if satisfied(i) { + break 2*i; + } + i += 1; +}; +``` diff --git a/src/librustc_error_codes/error_codes/E0572.md b/src/librustc_error_codes/error_codes/E0572.md new file mode 100644 index 00000000000..b2660650f1b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0572.md @@ -0,0 +1,24 @@ +A return statement was found outside of a function body. + +Erroneous code example: + +```compile_fail,E0572 +const FOO: u32 = return 0; // error: return statement outside of function body + +fn main() {} +``` + +To fix this issue, just remove the return keyword or move the expression into a +function. Example: + +``` +const FOO: u32 = 0; + +fn some_fn() -> u32 { + return FOO; +} + +fn main() { + some_fn(); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0573.md b/src/librustc_error_codes/error_codes/E0573.md new file mode 100644 index 00000000000..6021ed0ef21 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0573.md @@ -0,0 +1,71 @@ +Something other than a type has been used when one was expected. + +Erroneous code examples: + +```compile_fail,E0573 +enum Dragon { + Born, +} + +fn oblivion() -> Dragon::Born { // error! + Dragon::Born +} + +const HOBBIT: u32 = 2; +impl HOBBIT {} // error! + +enum Wizard { + Gandalf, + Saruman, +} + +trait Isengard { + fn wizard(_: Wizard::Saruman); // error! +} +``` + +In all these errors, a type was expected. For example, in the first error, if +we want to return the `Born` variant from the `Dragon` enum, we must set the +function to return the enum and not its variant: + +``` +enum Dragon { + Born, +} + +fn oblivion() -> Dragon { // ok! + Dragon::Born +} +``` + +In the second error, you can't implement something on an item, only on types. +We would need to create a new type if we wanted to do something similar: + +``` +struct Hobbit(u32); // we create a new type + +const HOBBIT: Hobbit = Hobbit(2); +impl Hobbit {} // ok! +``` + +In the third case, we tried to only expect one variant of the `Wizard` enum, +which is not possible. To make this work, we need to using pattern matching +over the `Wizard` enum: + +``` +enum Wizard { + Gandalf, + Saruman, +} + +trait Isengard { + fn wizard(w: Wizard) { // ok! + match w { + Wizard::Saruman => { + // do something + } + _ => {} // ignore everything else + } + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0574.md b/src/librustc_error_codes/error_codes/E0574.md new file mode 100644 index 00000000000..8154d5b782e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0574.md @@ -0,0 +1,47 @@ +Something other than a struct, variant or union has been used when one was +expected. + +Erroneous code example: + +```compile_fail,E0574 +mod Mordor {} + +let sauron = Mordor { x: () }; // error! + +enum Jak { + Daxter { i: isize }, +} + +let eco = Jak::Daxter { i: 1 }; +match eco { + Jak { i } => {} // error! +} +``` + +In all these errors, a type was expected. For example, in the first error, +we tried to instantiate the `Mordor` module, which is impossible. If you want +to instantiate a type inside a module, you can do it as follow: + +``` +mod Mordor { + pub struct TheRing { + pub x: usize, + } +} + +let sauron = Mordor::TheRing { x: 1 }; // ok! +``` + +In the second error, we tried to bind the `Jak` enum directly, which is not +possible: you can only bind one of its variants. To do so: + +``` +enum Jak { + Daxter { i: isize }, +} + +let eco = Jak::Daxter { i: 1 }; +match eco { + Jak::Daxter { i } => {} // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0575.md b/src/librustc_error_codes/error_codes/E0575.md new file mode 100644 index 00000000000..903939a9af9 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0575.md @@ -0,0 +1,50 @@ +Something other than a type or an associated type was given. + +Erroneous code example: + +```compile_fail,E0575 +enum Rick { Morty } + +let _: <u8 as Rick>::Morty; // error! + +trait Age { + type Empire; + fn Mythology() {} +} + +impl Age for u8 { + type Empire = u16; +} + +let _: <u8 as Age>::Mythology; // error! +``` + +In both cases, we're declaring a variable (called `_`) and we're giving it a +type. However, `<u8 as Rick>::Morty` and `<u8 as Age>::Mythology` aren't types, +therefore the compiler throws an error. + +`<u8 as Rick>::Morty` is an enum variant, you cannot use a variant as a type, +you have to use the enum directly: + +``` +enum Rick { Morty } + +let _: Rick; // ok! +``` + +`<u8 as Age>::Mythology` is a trait method, which is definitely not a type. +However, the `Age` trait provides an associated type `Empire` which can be +used as a type: + +``` +trait Age { + type Empire; + fn Mythology() {} +} + +impl Age for u8 { + type Empire = u16; +} + +let _: <u8 as Age>::Empire; // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0576.md b/src/librustc_error_codes/error_codes/E0576.md new file mode 100644 index 00000000000..8eead4e7e3b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0576.md @@ -0,0 +1,22 @@ +An associated item wasn't found in the given type. + +Erroneous code example: + +```compile_fail,E0576 +trait Hello { + type Who; + + fn hello() -> <Self as Hello>::You; // error! +} +``` + +In this example, we tried to use the non-existent associated type `You` of the +`Hello` trait. To fix this error, use an existing associated type: + +``` +trait Hello { + type Who; + + fn hello() -> <Self as Hello>::Who; // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0577.md b/src/librustc_error_codes/error_codes/E0577.md new file mode 100644 index 00000000000..1feb9c0acf3 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0577.md @@ -0,0 +1,24 @@ +Something other than a module was found in visibility scope. + +Erroneous code example: + +```compile_fail,E0577,edition2018 +pub struct Sea; + +pub (in crate::Sea) struct Shark; // error! + +fn main() {} +``` + +`Sea` is not a module, therefore it is invalid to use it in a visibility path. +To fix this error we need to ensure `Sea` is a module. + +Please note that the visibility scope can only be applied on ancestors! + +```edition2018 +pub mod Sea { + pub (in crate::Sea) struct Shark; // ok! +} + +fn main() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0578.md b/src/librustc_error_codes/error_codes/E0578.md new file mode 100644 index 00000000000..fca89757287 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0578.md @@ -0,0 +1,25 @@ +A module cannot be found and therefore, the visibility cannot be determined. + +Erroneous code example: + +```compile_fail,E0578,edition2018 +foo!(); + +pub (in ::Sea) struct Shark; // error! + +fn main() {} +``` + +Because of the call to the `foo` macro, the compiler guesses that the missing +module could be inside it and fails because the macro definition cannot be +found. + +To fix this error, please be sure that the module is in scope: + +```edition2018 +pub mod Sea { + pub (in crate::Sea) struct Shark; +} + +fn main() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0579.md b/src/librustc_error_codes/error_codes/E0579.md new file mode 100644 index 00000000000..225e27f0cab --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0579.md @@ -0,0 +1,19 @@ +When matching against an exclusive range, the compiler verifies that the range +is non-empty. Exclusive range patterns include the start point but not the end +point, so this is equivalent to requiring the start of the range to be less +than the end of the range. + +Erroneous code example: + +```compile_fail,E0579 +#![feature(exclusive_range_pattern)] + +fn main() { + match 5u32 { + // This range is ok, albeit pointless. + 1 .. 2 => {} + // This range is empty, and the compiler can tell. + 5 .. 5 => {} // error! + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0580.md b/src/librustc_error_codes/error_codes/E0580.md new file mode 100644 index 00000000000..260575d5de4 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0580.md @@ -0,0 +1,21 @@ +The `main` function was incorrectly declared. + +Erroneous code example: + +```compile_fail,E0580 +fn main(x: i32) { // error: main function has wrong type + println!("{}", x); +} +``` + +The `main` function prototype should never take arguments. +Example: + +``` +fn main() { + // your code +} +``` + +If you want to get command-line arguments, use `std::env::args`. To exit with a +specified exit code, use `std::process::exit`. diff --git a/src/librustc_error_codes/error_codes/E0581.md b/src/librustc_error_codes/error_codes/E0581.md new file mode 100644 index 00000000000..947ec255a9d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0581.md @@ -0,0 +1,28 @@ +In a `fn` type, a lifetime appears only in the return type, +and not in the arguments types. + +Erroneous code example: + +```compile_fail,E0581 +fn main() { + // Here, `'a` appears only in the return type: + let x: for<'a> fn() -> &'a i32; +} +``` + +To fix this issue, either use the lifetime in the arguments, or use +`'static`. Example: + +``` +fn main() { + // Here, `'a` appears only in the return type: + let x: for<'a> fn(&'a i32) -> &'a i32; + let y: fn() -> &'static i32; +} +``` + +Note: The examples above used to be (erroneously) accepted by the +compiler, but this was since corrected. See [issue #33685] for more +details. + +[issue #33685]: https://github.com/rust-lang/rust/issues/33685 diff --git a/src/librustc_error_codes/error_codes/E0582.md b/src/librustc_error_codes/error_codes/E0582.md new file mode 100644 index 00000000000..c0cf44852c4 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0582.md @@ -0,0 +1,34 @@ +A lifetime appears only in an associated-type binding, +and not in the input types to the trait. + +Erroneous code example: + +```compile_fail,E0582 +fn bar<F>(t: F) + // No type can satisfy this requirement, since `'a` does not + // appear in any of the input types (here, `i32`): + where F: for<'a> Fn(i32) -> Option<&'a i32> +{ +} + +fn main() { } +``` + +To fix this issue, either use the lifetime in the inputs, or use +`'static`. Example: + +``` +fn bar<F, G>(t: F, u: G) + where F: for<'a> Fn(&'a i32) -> Option<&'a i32>, + G: Fn(i32) -> Option<&'static i32>, +{ +} + +fn main() { } +``` + +Note: The examples above used to be (erroneously) accepted by the +compiler, but this was since corrected. See [issue #33685] for more +details. + +[issue #33685]: https://github.com/rust-lang/rust/issues/33685 diff --git a/src/librustc_error_codes/error_codes/E0583.md b/src/librustc_error_codes/error_codes/E0583.md new file mode 100644 index 00000000000..2dcbbf88556 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0583.md @@ -0,0 +1,14 @@ +A file wasn't found for an out-of-line module. + +Erroneous code example: + +```ignore (compile_fail not working here; see Issue #43707) +mod file_that_doesnt_exist; // error: file not found for module + +fn main() {} +``` + +Please be sure that a file corresponding to the module exists. If you +want to use a module named `file_that_doesnt_exist`, you need to have a file +named `file_that_doesnt_exist.rs` or `file_that_doesnt_exist/mod.rs` in the +same directory. diff --git a/src/librustc_error_codes/error_codes/E0584.md b/src/librustc_error_codes/error_codes/E0584.md new file mode 100644 index 00000000000..8b00655ee78 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0584.md @@ -0,0 +1,24 @@ +A doc comment that is not attached to anything has been encountered. + +Erroneous code example: + +```compile_fail,E0584 +trait Island { + fn lost(); + + /// I'm lost! +} +``` + +A little reminder: a doc comment has to be placed before the item it's supposed +to document. So if you want to document the `Island` trait, you need to put a +doc comment before it, not inside it. Same goes for the `lost` method: the doc +comment needs to be before it: + +``` +/// I'm THE island! +trait Island { + /// I'm lost! + fn lost(); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0585.md b/src/librustc_error_codes/error_codes/E0585.md new file mode 100644 index 00000000000..de27cc19d18 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0585.md @@ -0,0 +1,21 @@ +A documentation comment that doesn't document anything was found. + +Erroneous code example: + +```compile_fail,E0585 +fn main() { + // The following doc comment will fail: + /// This is a useless doc comment! +} +``` + +Documentation comments need to be followed by items, including functions, +types, modules, etc. Examples: + +``` +/// I'm documenting the following struct: +struct Foo; + +/// I'm documenting the following function: +fn foo() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0586.md b/src/librustc_error_codes/error_codes/E0586.md new file mode 100644 index 00000000000..bc6572ecadb --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0586.md @@ -0,0 +1,29 @@ +An inclusive range was used with no end. + +Erroneous code example: + +```compile_fail,E0586 +fn main() { + let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1]; + let x = &tmp[1..=]; // error: inclusive range was used with no end +} +``` + +An inclusive range needs an end in order to *include* it. If you just need a +start and no end, use a non-inclusive range (with `..`): + +``` +fn main() { + let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1]; + let x = &tmp[1..]; // ok! +} +``` + +Or put an end to your inclusive range: + +``` +fn main() { + let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1]; + let x = &tmp[1..=3]; // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0587.md b/src/librustc_error_codes/error_codes/E0587.md new file mode 100644 index 00000000000..ee9031dc379 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0587.md @@ -0,0 +1,16 @@ +A type has both `packed` and `align` representation hints. + +Erroneous code example: + +```compile_fail,E0587 +#[repr(packed, align(8))] // error! +struct Umbrella(i32); +``` + +You cannot use `packed` and `align` hints on a same type. If you want to pack a +type to a given size, you should provide a size to packed: + +``` +#[repr(packed)] // ok! +struct Umbrella(i32); +``` diff --git a/src/librustc_error_codes/error_codes/E0588.md b/src/librustc_error_codes/error_codes/E0588.md new file mode 100644 index 00000000000..040c7a02ef4 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0588.md @@ -0,0 +1,24 @@ +A type with `packed` representation hint has a field with `align` +representation hint. + +Erroneous code example: + +```compile_fail,E0588 +#[repr(align(16))] +struct Aligned(i32); + +#[repr(packed)] // error! +struct Packed(Aligned); +``` + +Just like you cannot have both `align` and `packed` representation hints on a +same type, a `packed` type cannot contain another type with the `align` +representation hint. However, you can do the opposite: + +``` +#[repr(packed)] +struct Packed(i32); + +#[repr(align(16))] // ok! +struct Aligned(Packed); +``` diff --git a/src/librustc_error_codes/error_codes/E0589.md b/src/librustc_error_codes/error_codes/E0589.md new file mode 100644 index 00000000000..5e15a875b0b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0589.md @@ -0,0 +1,9 @@ +The value of `N` that was specified for `repr(align(N))` was not a power +of two, or was greater than 2^29. + +```compile_fail,E0589 +#[repr(align(15))] // error: invalid `repr(align)` attribute: not a power of two +enum Foo { + Bar(u64), +} +``` diff --git a/src/librustc_error_codes/error_codes/E0590.md b/src/librustc_error_codes/error_codes/E0590.md new file mode 100644 index 00000000000..8032e45903c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0590.md @@ -0,0 +1,13 @@ +`break` or `continue` must include a label when used in the condition of a +`while` loop. + +Example of erroneous code: + +```compile_fail +while break {} +``` + +To fix this, add a label specifying which loop is being broken out of: +``` +'foo: while break 'foo {} +``` diff --git a/src/librustc_error_codes/error_codes/E0591.md b/src/librustc_error_codes/error_codes/E0591.md new file mode 100644 index 00000000000..782d4cf29c3 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0591.md @@ -0,0 +1,75 @@ +Per [RFC 401][rfc401], if you have a function declaration `foo`: + +``` +// For the purposes of this explanation, all of these +// different kinds of `fn` declarations are equivalent: +struct S; +fn foo(x: S) { /* ... */ } +# #[cfg(for_demonstration_only)] +extern "C" { fn foo(x: S); } +# #[cfg(for_demonstration_only)] +impl S { fn foo(self) { /* ... */ } } +``` + +the type of `foo` is **not** `fn(S)`, as one might expect. +Rather, it is a unique, zero-sized marker type written here as `typeof(foo)`. +However, `typeof(foo)` can be _coerced_ to a function pointer `fn(S)`, +so you rarely notice this: + +``` +# struct S; +# fn foo(_: S) {} +let x: fn(S) = foo; // OK, coerces +``` + +The reason that this matter is that the type `fn(S)` is not specific to +any particular function: it's a function _pointer_. So calling `x()` results +in a virtual call, whereas `foo()` is statically dispatched, because the type +of `foo` tells us precisely what function is being called. + +As noted above, coercions mean that most code doesn't have to be +concerned with this distinction. However, you can tell the difference +when using **transmute** to convert a fn item into a fn pointer. + +This is sometimes done as part of an FFI: + +```compile_fail,E0591 +extern "C" fn foo(userdata: Box<i32>) { + /* ... */ +} + +# fn callback(_: extern "C" fn(*mut i32)) {} +# use std::mem::transmute; +# unsafe { +let f: extern "C" fn(*mut i32) = transmute(foo); +callback(f); +# } +``` + +Here, transmute is being used to convert the types of the fn arguments. +This pattern is incorrect because, because the type of `foo` is a function +**item** (`typeof(foo)`), which is zero-sized, and the target type (`fn()`) +is a function pointer, which is not zero-sized. +This pattern should be rewritten. There are a few possible ways to do this: + +- change the original fn declaration to match the expected signature, + and do the cast in the fn body (the preferred option) +- cast the fn item fo a fn pointer before calling transmute, as shown here: + + ``` + # extern "C" fn foo(_: Box<i32>) {} + # use std::mem::transmute; + # unsafe { + let f: extern "C" fn(*mut i32) = transmute(foo as extern "C" fn(_)); + let f: extern "C" fn(*mut i32) = transmute(foo as usize); // works too + # } + ``` + +The same applies to transmutes to `*mut fn()`, which were observed in practice. +Note though that use of this type is generally incorrect. +The intention is typically to describe a function pointer, but just `fn()` +alone suffices for that. `*mut fn()` is a pointer to a fn pointer. +(Since these values are typically just passed to C code, however, this rarely +makes a difference in practice.) + +[rfc401]: https://github.com/rust-lang/rfcs/blob/master/text/0401-coercions.md diff --git a/src/librustc_error_codes/error_codes/E0592.md b/src/librustc_error_codes/error_codes/E0592.md new file mode 100644 index 00000000000..06959b5d765 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0592.md @@ -0,0 +1,31 @@ +This error occurs when you defined methods or associated functions with same +name. + +Erroneous code example: + +```compile_fail,E0592 +struct Foo; + +impl Foo { + fn bar() {} // previous definition here +} + +impl Foo { + fn bar() {} // duplicate definition here +} +``` + +A similar error is E0201. The difference is whether there is one declaration +block or not. To avoid this error, you must give each `fn` a unique name. + +``` +struct Foo; + +impl Foo { + fn bar() {} +} + +impl Foo { + fn baz() {} // define with different name +} +``` diff --git a/src/librustc_error_codes/error_codes/E0593.md b/src/librustc_error_codes/error_codes/E0593.md new file mode 100644 index 00000000000..b32923a9e5f --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0593.md @@ -0,0 +1,13 @@ +You tried to supply an `Fn`-based type with an incorrect number of arguments +than what was expected. + +Erroneous code example: + +```compile_fail,E0593 +fn foo<F: Fn()>(x: F) { } + +fn main() { + // [E0593] closure takes 1 argument but 0 arguments are required + foo(|y| { }); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0595.md b/src/librustc_error_codes/error_codes/E0595.md new file mode 100644 index 00000000000..e6729013243 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0595.md @@ -0,0 +1,17 @@ +#### Note: this error code is no longer emitted by the compiler. + +Closures cannot mutate immutable captured variables. + +Erroneous code example: + +```compile_fail,E0594 +let x = 3; // error: closure cannot assign to immutable local variable `x` +let mut c = || { x += 1 }; +``` + +Make the variable binding mutable: + +``` +let mut x = 3; // ok! +let mut c = || { x += 1 }; +``` diff --git a/src/librustc_error_codes/error_codes/E0596.md b/src/librustc_error_codes/error_codes/E0596.md new file mode 100644 index 00000000000..95669309b3b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0596.md @@ -0,0 +1,16 @@ +This error occurs because you tried to mutably borrow a non-mutable variable. + +Erroneous code example: + +```compile_fail,E0596 +let x = 1; +let y = &mut x; // error: cannot borrow mutably +``` + +In here, `x` isn't mutable, so when we try to mutably borrow it in `y`, it +fails. To fix this error, you need to make `x` mutable: + +``` +let mut x = 1; +let y = &mut x; // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0597.md b/src/librustc_error_codes/error_codes/E0597.md new file mode 100644 index 00000000000..3340768fa82 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0597.md @@ -0,0 +1,33 @@ +This error occurs because a value was dropped while it was still borrowed + +Erroneous code example: + +```compile_fail,E0597 +struct Foo<'a> { + x: Option<&'a u32>, +} + +let mut x = Foo { x: None }; +{ + let y = 0; + x.x = Some(&y); // error: `y` does not live long enough +} +println!("{:?}", x.x); +``` + +In here, `y` is dropped at the end of the inner scope, but it is borrowed by +`x` until the `println`. To fix the previous example, just remove the scope +so that `y` isn't dropped until after the println + +``` +struct Foo<'a> { + x: Option<&'a u32>, +} + +let mut x = Foo { x: None }; + +let y = 0; +x.x = Some(&y); + +println!("{:?}", x.x); +``` diff --git a/src/librustc_error_codes/error_codes/E0599.md b/src/librustc_error_codes/error_codes/E0599.md new file mode 100644 index 00000000000..c44e60571e1 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0599.md @@ -0,0 +1,11 @@ +This error occurs when a method is used on a type which doesn't implement it: + +Erroneous code example: + +```compile_fail,E0599 +struct Mouth; + +let x = Mouth; +x.chocolate(); // error: no method named `chocolate` found for type `Mouth` + // in the current scope +``` diff --git a/src/librustc_error_codes/error_codes/E0600.md b/src/librustc_error_codes/error_codes/E0600.md new file mode 100644 index 00000000000..172e2a346c5 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0600.md @@ -0,0 +1,40 @@ +An unary operator was used on a type which doesn't implement it. + +Example of erroneous code: + +```compile_fail,E0600 +enum Question { + Yes, + No, +} + +!Question::Yes; // error: cannot apply unary operator `!` to type `Question` +``` + +In this case, `Question` would need to implement the `std::ops::Not` trait in +order to be able to use `!` on it. Let's implement it: + +``` +use std::ops::Not; + +enum Question { + Yes, + No, +} + +// We implement the `Not` trait on the enum. +impl Not for Question { + type Output = bool; + + fn not(self) -> bool { + match self { + Question::Yes => false, // If the `Answer` is `Yes`, then it + // returns false. + Question::No => true, // And here we do the opposite. + } + } +} + +assert_eq!(!Question::Yes, false); +assert_eq!(!Question::No, true); +``` diff --git a/src/librustc_error_codes/error_codes/E0601.md b/src/librustc_error_codes/error_codes/E0601.md new file mode 100644 index 00000000000..12ae767c9e6 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0601.md @@ -0,0 +1,12 @@ +No `main` function was found in a binary crate. To fix this error, add a +`main` function. For example: + +``` +fn main() { + // Your program will start here. + println!("Hello world!"); +} +``` + +If you don't know the basics of Rust, you can go look to the Rust Book to get +started: https://doc.rust-lang.org/book/ diff --git a/src/librustc_error_codes/error_codes/E0602.md b/src/librustc_error_codes/error_codes/E0602.md new file mode 100644 index 00000000000..ca7138a60cc --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0602.md @@ -0,0 +1,10 @@ +An unknown lint was used on the command line. + +Erroneous example: + +```sh +rustc -D bogus omse_file.rs +``` + +Maybe you just misspelled the lint name or the lint doesn't exist anymore. +Either way, try to update/remove it in order to fix the error. diff --git a/src/librustc_error_codes/error_codes/E0603.md b/src/librustc_error_codes/error_codes/E0603.md new file mode 100644 index 00000000000..69fefce3908 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0603.md @@ -0,0 +1,26 @@ +A private item was used outside its scope. + +Erroneous code example: + +```compile_fail,E0603 +mod SomeModule { + const PRIVATE: u32 = 0x_a_bad_1dea_u32; // This const is private, so we + // can't use it outside of the + // `SomeModule` module. +} + +println!("const value: {}", SomeModule::PRIVATE); // error: constant `PRIVATE` + // is private +``` + +In order to fix this error, you need to make the item public by using the `pub` +keyword. Example: + +``` +mod SomeModule { + pub const PRIVATE: u32 = 0x_a_bad_1dea_u32; // We set it public by using the + // `pub` keyword. +} + +println!("const value: {}", SomeModule::PRIVATE); // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0604.md b/src/librustc_error_codes/error_codes/E0604.md new file mode 100644 index 00000000000..adbf76509ed --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0604.md @@ -0,0 +1,19 @@ +A cast to `char` was attempted on a type other than `u8`. + +Erroneous code example: + +```compile_fail,E0604 +0u32 as char; // error: only `u8` can be cast as `char`, not `u32` +``` + +As the error message indicates, only `u8` can be cast into `char`. Example: + +``` +let c = 86u8 as char; // ok! +assert_eq!(c, 'V'); +``` + +For more information about casts, take a look at the Type cast section in +[The Reference Book][1]. + +[1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions diff --git a/src/librustc_error_codes/error_codes/E0605.md b/src/librustc_error_codes/error_codes/E0605.md new file mode 100644 index 00000000000..f3cc65dd8cf --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0605.md @@ -0,0 +1,28 @@ +An invalid cast was attempted. + +Erroneous code examples: + +```compile_fail,E0605 +let x = 0u8; +x as Vec<u8>; // error: non-primitive cast: `u8` as `std::vec::Vec<u8>` + +// Another example + +let v = core::ptr::null::<u8>(); // So here, `v` is a `*const u8`. +v as &u8; // error: non-primitive cast: `*const u8` as `&u8` +``` + +Only primitive types can be cast into each other. Examples: + +``` +let x = 0u8; +x as u32; // ok! + +let v = core::ptr::null::<u8>(); +v as *const i8; // ok! +``` + +For more information about casts, take a look at the Type cast section in +[The Reference Book][1]. + +[1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions diff --git a/src/librustc_error_codes/error_codes/E0606.md b/src/librustc_error_codes/error_codes/E0606.md new file mode 100644 index 00000000000..06ee7497fdf --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0606.md @@ -0,0 +1,21 @@ +An incompatible cast was attempted. + +Erroneous code example: + +```compile_fail,E0606 +let x = &0u8; // Here, `x` is a `&u8`. +let y: u32 = x as u32; // error: casting `&u8` as `u32` is invalid +``` + +When casting, keep in mind that only primitive types can be cast into each +other. Example: + +``` +let x = &0u8; +let y: u32 = *x as u32; // We dereference it first and then cast it. +``` + +For more information about casts, take a look at the Type cast section in +[The Reference Book][1]. + +[1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions diff --git a/src/librustc_error_codes/error_codes/E0607.md b/src/librustc_error_codes/error_codes/E0607.md new file mode 100644 index 00000000000..ea6e10105b0 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0607.md @@ -0,0 +1,26 @@ +A cast between a thin and a fat pointer was attempted. + +Erroneous code example: + +```compile_fail,E0607 +let v = core::ptr::null::<u8>(); +v as *const [u8]; +``` + +First: what are thin and fat pointers? + +Thin pointers are "simple" pointers: they are purely a reference to a memory +address. + +Fat pointers are pointers referencing Dynamically Sized Types (also called DST). +DST don't have a statically known size, therefore they can only exist behind +some kind of pointers that contain additional information. Slices and trait +objects are DSTs. In the case of slices, the additional information the fat +pointer holds is their size. + +To fix this error, don't try to cast directly between thin and fat pointers. + +For more information about casts, take a look at the Type cast section in +[The Reference Book][1]. + +[1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions diff --git a/src/librustc_error_codes/error_codes/E0608.md b/src/librustc_error_codes/error_codes/E0608.md new file mode 100644 index 00000000000..598f1e655e9 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0608.md @@ -0,0 +1,18 @@ +An attempt to index into a type which doesn't implement the `std::ops::Index` +trait was performed. + +Erroneous code example: + +```compile_fail,E0608 +0u8[2]; // error: cannot index into a value of type `u8` +``` + +To be able to index into a type it needs to implement the `std::ops::Index` +trait. Example: + +``` +let v: Vec<u8> = vec![0, 1, 2, 3]; + +// The `Vec` type implements the `Index` trait so you can do: +println!("{}", v[2]); +``` diff --git a/src/librustc_error_codes/error_codes/E0609.md b/src/librustc_error_codes/error_codes/E0609.md new file mode 100644 index 00000000000..a9db34f474e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0609.md @@ -0,0 +1,24 @@ +Attempted to access a non-existent field in a struct. + +Erroneous code example: + +```compile_fail,E0609 +struct StructWithFields { + x: u32, +} + +let s = StructWithFields { x: 0 }; +println!("{}", s.foo); // error: no field `foo` on type `StructWithFields` +``` + +To fix this error, check that you didn't misspell the field's name or that the +field actually exists. Example: + +``` +struct StructWithFields { + x: u32, +} + +let s = StructWithFields { x: 0 }; +println!("{}", s.x); // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0610.md b/src/librustc_error_codes/error_codes/E0610.md new file mode 100644 index 00000000000..d590ce51a33 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0610.md @@ -0,0 +1,29 @@ +Attempted to access a field on a primitive type. + +Erroneous code example: + +```compile_fail,E0610 +let x: u32 = 0; +println!("{}", x.foo); // error: `{integer}` is a primitive type, therefore + // doesn't have fields +``` + +Primitive types are the most basic types available in Rust and don't have +fields. To access data via named fields, struct types are used. Example: + +``` +// We declare struct called `Foo` containing two fields: +struct Foo { + x: u32, + y: i64, +} + +// We create an instance of this struct: +let variable = Foo { x: 0, y: -12 }; +// And we can now access its fields: +println!("x: {}, y: {}", variable.x, variable.y); +``` + +For more information about primitives and structs, take a look at The Book: +https://doc.rust-lang.org/book/ch03-02-data-types.html +https://doc.rust-lang.org/book/ch05-00-structs.html diff --git a/src/librustc_error_codes/error_codes/E0614.md b/src/librustc_error_codes/error_codes/E0614.md new file mode 100644 index 00000000000..d0ed06ebcee --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0614.md @@ -0,0 +1,18 @@ +Attempted to dereference a variable which cannot be dereferenced. + +Erroneous code example: + +```compile_fail,E0614 +let y = 0u32; +*y; // error: type `u32` cannot be dereferenced +``` + +Only types implementing `std::ops::Deref` can be dereferenced (such as `&T`). +Example: + +``` +let y = 0u32; +let x = &y; +// So here, `x` is a `&u32`, so we can dereference it: +*x; // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0615.md b/src/librustc_error_codes/error_codes/E0615.md new file mode 100644 index 00000000000..f513d059625 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0615.md @@ -0,0 +1,35 @@ +Attempted to access a method like a field. + +Erroneous code example: + +```compile_fail,E0615 +struct Foo { + x: u32, +} + +impl Foo { + fn method(&self) {} +} + +let f = Foo { x: 0 }; +f.method; // error: attempted to take value of method `method` on type `Foo` +``` + +If you want to use a method, add `()` after it: + +``` +# struct Foo { x: u32 } +# impl Foo { fn method(&self) {} } +# let f = Foo { x: 0 }; +f.method(); +``` + +However, if you wanted to access a field of a struct check that the field name +is spelled correctly. Example: + +``` +# struct Foo { x: u32 } +# impl Foo { fn method(&self) {} } +# let f = Foo { x: 0 }; +println!("{}", f.x); +``` diff --git a/src/librustc_error_codes/error_codes/E0616.md b/src/librustc_error_codes/error_codes/E0616.md new file mode 100644 index 00000000000..5acbc6e44e1 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0616.md @@ -0,0 +1,57 @@ +Attempted to access a private field on a struct. + +Erroneous code example: + +```compile_fail,E0616 +mod some_module { + pub struct Foo { + x: u32, // So `x` is private in here. + } + + impl Foo { + pub fn new() -> Foo { Foo { x: 0 } } + } +} + +let f = some_module::Foo::new(); +println!("{}", f.x); // error: field `x` of struct `some_module::Foo` is private +``` + +If you want to access this field, you have two options: + +1) Set the field public: + +``` +mod some_module { + pub struct Foo { + pub x: u32, // `x` is now public. + } + + impl Foo { + pub fn new() -> Foo { Foo { x: 0 } } + } +} + +let f = some_module::Foo::new(); +println!("{}", f.x); // ok! +``` + +2) Add a getter function: + +``` +mod some_module { + pub struct Foo { + x: u32, // So `x` is still private in here. + } + + impl Foo { + pub fn new() -> Foo { Foo { x: 0 } } + + // We create the getter function here: + pub fn get_x(&self) -> &u32 { &self.x } + } +} + +let f = some_module::Foo::new(); +println!("{}", f.get_x()); // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0617.md b/src/librustc_error_codes/error_codes/E0617.md new file mode 100644 index 00000000000..f4357ff755e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0617.md @@ -0,0 +1,19 @@ +Attempted to pass an invalid type of variable into a variadic function. + +Erroneous code example: + +```compile_fail,E0617 +extern { + fn printf(c: *const i8, ...); +} + +unsafe { + printf(::std::ptr::null(), 0f32); + // error: cannot pass an `f32` to variadic function, cast to `c_double` +} +``` + +Certain Rust types must be cast before passing them to a variadic function, +because of arcane ABI rules dictated by the C standard. To fix the error, +cast the value to the type specified by the error message (which you may need +to import from `std::os::raw`). diff --git a/src/librustc_error_codes/error_codes/E0618.md b/src/librustc_error_codes/error_codes/E0618.md new file mode 100644 index 00000000000..c8dc9040cf1 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0618.md @@ -0,0 +1,26 @@ +Attempted to call something which isn't a function nor a method. + +Erroneous code examples: + +```compile_fail,E0618 +enum X { + Entry, +} + +X::Entry(); // error: expected function, tuple struct or tuple variant, + // found `X::Entry` + +// Or even simpler: +let x = 0i32; +x(); // error: expected function, tuple struct or tuple variant, found `i32` +``` + +Only functions and methods can be called using `()`. Example: + +``` +// We declare a function: +fn i_am_a_function() {} + +// And we call it: +i_am_a_function(); +``` diff --git a/src/librustc_error_codes/error_codes/E0619.md b/src/librustc_error_codes/error_codes/E0619.md new file mode 100644 index 00000000000..8727692c0a5 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0619.md @@ -0,0 +1,38 @@ +#### Note: this error code is no longer emitted by the compiler. +The type-checker needed to know the type of an expression, but that type had not +yet been inferred. + +Erroneous code example: + +```compile_fail +let mut x = vec![]; +match x.pop() { + Some(v) => { + // Here, the type of `v` is not (yet) known, so we + // cannot resolve this method call: + v.to_uppercase(); // error: the type of this value must be known in + // this context + } + None => {} +} +``` + +Type inference typically proceeds from the top of the function to the bottom, +figuring out types as it goes. In some cases -- notably method calls and +overloadable operators like `*` -- the type checker may not have enough +information *yet* to make progress. This can be true even if the rest of the +function provides enough context (because the type-checker hasn't looked that +far ahead yet). In this case, type annotations can be used to help it along. + +To fix this error, just specify the type of the variable. Example: + +``` +let mut x: Vec<String> = vec![]; // We precise the type of the vec elements. +match x.pop() { + Some(v) => { + v.to_uppercase(); // Since rustc now knows the type of the vec elements, + // we can use `v`'s methods. + } + None => {} +} +``` diff --git a/src/librustc_error_codes/error_codes/E0620.md b/src/librustc_error_codes/error_codes/E0620.md new file mode 100644 index 00000000000..f8e442807e5 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0620.md @@ -0,0 +1,18 @@ +A cast to an unsized type was attempted. + +Erroneous code example: + +```compile_fail,E0620 +let x = &[1_usize, 2] as [usize]; // error: cast to unsized type: `&[usize; 2]` + // as `[usize]` +``` + +In Rust, some types don't have a known size at compile-time. For example, in a +slice type like `[u32]`, the number of elements is not known at compile-time and +hence the overall size cannot be computed. As a result, such types can only be +manipulated through a reference (e.g., `&T` or `&mut T`) or other pointer-type +(e.g., `Box` or `Rc`). Try casting to a reference instead: + +``` +let x = &[1_usize, 2] as &[usize]; // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0621.md b/src/librustc_error_codes/error_codes/E0621.md new file mode 100644 index 00000000000..7c0878df25e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0621.md @@ -0,0 +1,34 @@ +This error code indicates a mismatch between the lifetimes appearing in the +function signature (i.e., the parameter types and the return type) and the +data-flow found in the function body. + +Erroneous code example: + +```compile_fail,E0621 +fn foo<'a>(x: &'a i32, y: &i32) -> &'a i32 { // error: explicit lifetime + // required in the type of + // `y` + if x > y { x } else { y } +} +``` + +In the code above, the function is returning data borrowed from either `x` or +`y`, but the `'a` annotation indicates that it is returning data only from `x`. +To fix the error, the signature and the body must be made to match. Typically, +this is done by updating the function signature. So, in this case, we change +the type of `y` to `&'a i32`, like so: + +``` +fn foo<'a>(x: &'a i32, y: &'a i32) -> &'a i32 { + if x > y { x } else { y } +} +``` + +Now the signature indicates that the function data borrowed from either `x` or +`y`. Alternatively, you could change the body to not return data from `y`: + +``` +fn foo<'a>(x: &'a i32, y: &i32) -> &'a i32 { + x +} +``` diff --git a/src/librustc_error_codes/error_codes/E0622.md b/src/librustc_error_codes/error_codes/E0622.md new file mode 100644 index 00000000000..1de81dabb29 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0622.md @@ -0,0 +1,17 @@ +An intrinsic was declared without being a function. + +Erroneous code example: + +```compile_fail,E0622 +#![feature(intrinsics)] +extern "rust-intrinsic" { + pub static breakpoint : unsafe extern "rust-intrinsic" fn(); + // error: intrinsic must be a function +} + +fn main() { unsafe { breakpoint(); } } +``` + +An intrinsic is a function available for use in a given programming language +whose implementation is handled specially by the compiler. In order to fix this +error, just declare a function. diff --git a/src/librustc_error_codes/error_codes/E0623.md b/src/librustc_error_codes/error_codes/E0623.md new file mode 100644 index 00000000000..1290edd0a0e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0623.md @@ -0,0 +1,41 @@ +A lifetime didn't match what was expected. + +Erroneous code example: + +```compile_fail,E0623 +struct Foo<'a> { + x: &'a isize, +} + +fn bar<'short, 'long>(c: Foo<'short>, l: &'long isize) { + let _: Foo<'long> = c; // error! +} +``` + +In this example, we tried to set a value with an incompatible lifetime to +another one (`'long` is unrelated to `'short`). We can solve this issue in +two different ways: + +Either we make `'short` live at least as long as `'long`: + +``` +struct Foo<'a> { + x: &'a isize, +} + +// we set 'short to live at least as long as 'long +fn bar<'short: 'long, 'long>(c: Foo<'short>, l: &'long isize) { + let _: Foo<'long> = c; // ok! +} +``` + +Or we use only one lifetime: + +``` +struct Foo<'a> { + x: &'a isize, +} +fn bar<'short>(c: Foo<'short>, l: &'short isize) { + let _: Foo<'short> = c; // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0624.md b/src/librustc_error_codes/error_codes/E0624.md new file mode 100644 index 00000000000..0fd21c44b3d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0624.md @@ -0,0 +1,53 @@ +A private item was used outside of its scope. + +Erroneous code example: + +```compile_fail,E0624 +mod inner { + pub struct Foo; + + impl Foo { + fn method(&self) {} + } +} + +let foo = inner::Foo; +foo.method(); // error: method `method` is private +``` + +Two possibilities are available to solve this issue: + +1. Only use the item in the scope it has been defined: + +``` +mod inner { + pub struct Foo; + + impl Foo { + fn method(&self) {} + } + + pub fn call_method(foo: &Foo) { // We create a public function. + foo.method(); // Which calls the item. + } +} + +let foo = inner::Foo; +inner::call_method(&foo); // And since the function is public, we can call the + // method through it. +``` + +2. Make the item public: + +``` +mod inner { + pub struct Foo; + + impl Foo { + pub fn method(&self) {} // It's now public. + } +} + +let foo = inner::Foo; +foo.method(); // Ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0626.md b/src/librustc_error_codes/error_codes/E0626.md new file mode 100644 index 00000000000..db50bd7ac4f --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0626.md @@ -0,0 +1,90 @@ +This error occurs because a borrow in a generator persists across a +yield point. + +Erroneous code example: + +```compile_fail,E0626 +# #![feature(generators, generator_trait, pin)] +# use std::ops::Generator; +# use std::pin::Pin; +let mut b = || { + let a = &String::new(); // <-- This borrow... + yield (); // ...is still in scope here, when the yield occurs. + println!("{}", a); +}; +Pin::new(&mut b).resume(); +``` + +At present, it is not permitted to have a yield that occurs while a +borrow is still in scope. To resolve this error, the borrow must +either be "contained" to a smaller scope that does not overlap the +yield or else eliminated in another way. So, for example, we might +resolve the previous example by removing the borrow and just storing +the integer by value: + +``` +# #![feature(generators, generator_trait, pin)] +# use std::ops::Generator; +# use std::pin::Pin; +let mut b = || { + let a = 3; + yield (); + println!("{}", a); +}; +Pin::new(&mut b).resume(); +``` + +This is a very simple case, of course. In more complex cases, we may +wish to have more than one reference to the value that was borrowed -- +in those cases, something like the `Rc` or `Arc` types may be useful. + +This error also frequently arises with iteration: + +```compile_fail,E0626 +# #![feature(generators, generator_trait, pin)] +# use std::ops::Generator; +# use std::pin::Pin; +let mut b = || { + let v = vec![1,2,3]; + for &x in &v { // <-- borrow of `v` is still in scope... + yield x; // ...when this yield occurs. + } +}; +Pin::new(&mut b).resume(); +``` + +Such cases can sometimes be resolved by iterating "by value" (or using +`into_iter()`) to avoid borrowing: + +``` +# #![feature(generators, generator_trait, pin)] +# use std::ops::Generator; +# use std::pin::Pin; +let mut b = || { + let v = vec![1,2,3]; + for x in v { // <-- Take ownership of the values instead! + yield x; // <-- Now yield is OK. + } +}; +Pin::new(&mut b).resume(); +``` + +If taking ownership is not an option, using indices can work too: + +``` +# #![feature(generators, generator_trait, pin)] +# use std::ops::Generator; +# use std::pin::Pin; +let mut b = || { + let v = vec![1,2,3]; + let len = v.len(); // (*) + for i in 0..len { + let x = v[i]; // (*) + yield x; // <-- Now yield is OK. + } +}; +Pin::new(&mut b).resume(); + +// (*) -- Unfortunately, these temporaries are currently required. +// See <https://github.com/rust-lang/rust/issues/43122>. +``` diff --git a/src/librustc_error_codes/error_codes/E0633.md b/src/librustc_error_codes/error_codes/E0633.md new file mode 100644 index 00000000000..a68da1188b5 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0633.md @@ -0,0 +1,24 @@ +The `unwind` attribute was malformed. + +Erroneous code example: + +```ignore (compile_fail not working here; see Issue #43707) +#[unwind()] // error: expected one argument +pub extern fn something() {} + +fn main() {} +``` + +The `#[unwind]` attribute should be used as follows: + +- `#[unwind(aborts)]` -- specifies that if a non-Rust ABI function + should abort the process if it attempts to unwind. This is the safer + and preferred option. + +- `#[unwind(allowed)]` -- specifies that a non-Rust ABI function + should be allowed to unwind. This can easily result in Undefined + Behavior (UB), so be careful. + +NB. The default behavior here is "allowed", but this is unspecified +and likely to change in the future. + diff --git a/src/librustc_error_codes/error_codes/E0635.md b/src/librustc_error_codes/error_codes/E0635.md new file mode 100644 index 00000000000..2382ce0d3ff --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0635.md @@ -0,0 +1,8 @@ +The `#![feature]` attribute specified an unknown feature. + +Erroneous code example: + +```compile_fail,E0635 +#![feature(nonexistent_rust_feature)] // error: unknown feature +``` + diff --git a/src/librustc_error_codes/error_codes/E0636.md b/src/librustc_error_codes/error_codes/E0636.md new file mode 100644 index 00000000000..dabf9b64123 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0636.md @@ -0,0 +1,10 @@ +A `#![feature]` attribute was declared multiple times. + +Erroneous code example: + +```compile_fail,E0636 +#![allow(stable_features)] +#![feature(rust1)] +#![feature(rust1)] // error: the feature `rust1` has already been declared +``` + diff --git a/src/librustc_error_codes/error_codes/E0638.md b/src/librustc_error_codes/error_codes/E0638.md new file mode 100644 index 00000000000..29b7586b07b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0638.md @@ -0,0 +1,47 @@ +This error indicates that the struct, enum or enum variant must be matched +non-exhaustively as it has been marked as `non_exhaustive`. + +When applied within a crate, downstream users of the crate will need to use the +`_` pattern when matching enums and use the `..` pattern when matching structs. +Downstream crates cannot match against non-exhaustive enum variants. + +For example, in the below example, since the enum is marked as +`non_exhaustive`, it is required that downstream crates match non-exhaustively +on it. + +```rust,ignore (pseudo-Rust) +use std::error::Error as StdError; + +#[non_exhaustive] pub enum Error { + Message(String), + Other, +} + +impl StdError for Error { + fn description(&self) -> &str { + // This will not error, despite being marked as non_exhaustive, as this + // enum is defined within the current crate, it can be matched + // exhaustively. + match *self { + Message(ref s) => s, + Other => "other or unknown error", + } + } +} +``` + +An example of matching non-exhaustively on the above enum is provided below: + +```rust,ignore (pseudo-Rust) +use mycrate::Error; + +// This will not error as the non_exhaustive Error enum has been matched with a +// wildcard. +match error { + Message(ref s) => ..., + Other => ..., + _ => ..., +} +``` + +Similarly, for structs, match with `..` to avoid this error. diff --git a/src/librustc_error_codes/error_codes/E0639.md b/src/librustc_error_codes/error_codes/E0639.md new file mode 100644 index 00000000000..c2d9662337f --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0639.md @@ -0,0 +1,7 @@ +This error indicates that the struct, enum or enum variant cannot be +instantiated from outside of the defining crate as it has been marked +as `non_exhaustive` and as such more fields/variants may be added in +future that could cause adverse side effects for this code. + +It is recommended that you look for a `new` function or equivalent in the +crate's documentation. diff --git a/src/librustc_error_codes/error_codes/E0642.md b/src/librustc_error_codes/error_codes/E0642.md new file mode 100644 index 00000000000..592ada6ecad --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0642.md @@ -0,0 +1,18 @@ +Trait methods currently cannot take patterns as arguments. + +Example of erroneous code: + +```compile_fail,E0642 +trait Foo { + fn foo((x, y): (i32, i32)); // error: patterns aren't allowed + // in trait methods +} +``` + +You can instead use a single name for the argument: + +``` +trait Foo { + fn foo(x_and_y: (i32, i32)); // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0643.md b/src/librustc_error_codes/error_codes/E0643.md new file mode 100644 index 00000000000..53919607dfb --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0643.md @@ -0,0 +1,12 @@ +This error indicates that there is a mismatch between generic parameters and +impl Trait parameters in a trait declaration versus its impl. + +```compile_fail,E0643 +trait Foo { + fn foo(&self, _: &impl Iterator); +} +impl Foo for () { + fn foo<U: Iterator>(&self, _: &U) { } // error method `foo` has incompatible + // signature for trait +} +``` diff --git a/src/librustc_error_codes/error_codes/E0644.md b/src/librustc_error_codes/error_codes/E0644.md new file mode 100644 index 00000000000..61acb084a45 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0644.md @@ -0,0 +1,30 @@ +A closure or generator was constructed that references its own type. + +Erroneous example: + +```compile-fail,E0644 +fn fix<F>(f: &F) + where F: Fn(&F) +{ + f(&f); +} + +fn main() { + fix(&|y| { + // Here, when `x` is called, the parameter `y` is equal to `x`. + }); +} +``` + +Rust does not permit a closure to directly reference its own type, +either through an argument (as in the example above) or by capturing +itself through its environment. This restriction helps keep closure +inference tractable. + +The easiest fix is to rewrite your closure into a top-level function, +or into a method. In some cases, you may also be able to have your +closure call itself by capturing a `&Fn()` object or `fn()` pointer +that refers to itself. That is permitting, since the closure would be +invoking itself via a virtual call, and hence does not directly +reference its own *type*. + diff --git a/src/librustc_error_codes/error_codes/E0646.md b/src/librustc_error_codes/error_codes/E0646.md new file mode 100644 index 00000000000..e01dbae8b90 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0646.md @@ -0,0 +1,8 @@ +It is not possible to define `main` with a where clause. +Erroneous code example: + +```compile_fail,E0646 +fn main() where i32: Copy { // error: main function is not allowed to have + // a where clause +} +``` diff --git a/src/librustc_error_codes/error_codes/E0647.md b/src/librustc_error_codes/error_codes/E0647.md new file mode 100644 index 00000000000..131db38c00d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0647.md @@ -0,0 +1,12 @@ +It is not possible to define `start` with a where clause. +Erroneous code example: + +```compile_fail,E0647 +#![feature(start)] + +#[start] +fn start(_: isize, _: *const *const u8) -> isize where (): Copy { + //^ error: start function is not allowed to have a where clause + 0 +} +``` diff --git a/src/librustc_error_codes/error_codes/E0648.md b/src/librustc_error_codes/error_codes/E0648.md new file mode 100644 index 00000000000..319bae103f3 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0648.md @@ -0,0 +1,6 @@ +`export_name` attributes may not contain null characters (`\0`). + +```compile_fail,E0648 +#[export_name="\0foo"] // error: `export_name` may not contain null characters +pub fn bar() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0658.md b/src/librustc_error_codes/error_codes/E0658.md new file mode 100644 index 00000000000..44a38cee23d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0658.md @@ -0,0 +1,26 @@ +An unstable feature was used. + +Erroneous code example: + +```compile_fail,E658 +#[repr(u128)] // error: use of unstable library feature 'repr128' +enum Foo { + Bar(u64), +} +``` + +If you're using a stable or a beta version of rustc, you won't be able to use +any unstable features. In order to do so, please switch to a nightly version of +rustc (by using rustup). + +If you're using a nightly version of rustc, just add the corresponding feature +to be able to use it: + +``` +#![feature(repr128)] + +#[repr(u128)] // ok! +enum Foo { + Bar(u64), +} +``` diff --git a/src/librustc_error_codes/error_codes/E0659.md b/src/librustc_error_codes/error_codes/E0659.md new file mode 100644 index 00000000000..e2c7e25cc84 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0659.md @@ -0,0 +1,50 @@ +An item usage is ambiguous. + +Erroneous code example: + +```compile_fail,edition2018,E0659 +pub mod moon { + pub fn foo() {} +} + +pub mod earth { + pub fn foo() {} +} + +mod collider { + pub use crate::moon::*; + pub use crate::earth::*; +} + +fn main() { + crate::collider::foo(); // ERROR: `foo` is ambiguous +} +``` + +This error generally appears when two items with the same name are imported into +a module. Here, the `foo` functions are imported and reexported from the +`collider` module and therefore, when we're using `collider::foo()`, both +functions collide. + +To solve this error, the best solution is generally to keep the path before the +item when using it. Example: + +```edition2018 +pub mod moon { + pub fn foo() {} +} + +pub mod earth { + pub fn foo() {} +} + +mod collider { + pub use crate::moon; + pub use crate::earth; +} + +fn main() { + crate::collider::moon::foo(); // ok! + crate::collider::earth::foo(); // ok! +} +``` diff --git a/src/librustc_error_codes/error_codes/E0660.md b/src/librustc_error_codes/error_codes/E0660.md new file mode 100644 index 00000000000..bceab1e0055 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0660.md @@ -0,0 +1,11 @@ +The argument to the `asm` macro is not well-formed. + +Erroneous code example: + +```compile_fail,E0660 +asm!("nop" "nop"); +``` + +Considering that this would be a long explanation, we instead recommend you to +take a look at the unstable book: +https://doc.rust-lang.org/unstable-book/language-features/asm.html diff --git a/src/librustc_error_codes/error_codes/E0661.md b/src/librustc_error_codes/error_codes/E0661.md new file mode 100644 index 00000000000..9979a61ee95 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0661.md @@ -0,0 +1,12 @@ +An invalid syntax was passed to the second argument of an `asm` macro line. + +Erroneous code example: + +```compile_fail,E0661 +let a; +asm!("nop" : "r"(a)); +``` + +Considering that this would be a long explanation, we instead recommend you to +take a look at the unstable book: +https://doc.rust-lang.org/unstable-book/language-features/asm.html diff --git a/src/librustc_error_codes/error_codes/E0662.md b/src/librustc_error_codes/error_codes/E0662.md new file mode 100644 index 00000000000..3ba00eaab54 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0662.md @@ -0,0 +1,14 @@ +An invalid input operand constraint was passed to the `asm` macro (third line). + +Erroneous code example: + +```compile_fail,E0662 +asm!("xor %eax, %eax" + : + : "=test"("a") + ); +``` + +Considering that this would be a long explanation, we instead recommend you to +take a look at the unstable book: +https://doc.rust-lang.org/unstable-book/language-features/asm.html diff --git a/src/librustc_error_codes/error_codes/E0663.md b/src/librustc_error_codes/error_codes/E0663.md new file mode 100644 index 00000000000..be121aa0b72 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0663.md @@ -0,0 +1,14 @@ +An invalid input operand constraint was passed to the `asm` macro (third line). + +Erroneous code example: + +```compile_fail,E0663 +asm!("xor %eax, %eax" + : + : "+test"("a") + ); +``` + +Considering that this would be a long explanation, we instead recommend you to +take a look at the unstable book: +https://doc.rust-lang.org/unstable-book/language-features/asm.html diff --git a/src/librustc_error_codes/error_codes/E0664.md b/src/librustc_error_codes/error_codes/E0664.md new file mode 100644 index 00000000000..2b9546453d1 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0664.md @@ -0,0 +1,15 @@ +A clobber was surrounded by braces in the `asm` macro. + +Erroneous code example: + +```compile_fail,E0664 +asm!("mov $$0x200, %eax" + : + : + : "{eax}" + ); +``` + +Considering that this would be a long explanation, we instead recommend you to +take a look at the unstable book: +https://doc.rust-lang.org/unstable-book/language-features/asm.html diff --git a/src/librustc_error_codes/error_codes/E0665.md b/src/librustc_error_codes/error_codes/E0665.md new file mode 100644 index 00000000000..a15f4021c71 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0665.md @@ -0,0 +1,31 @@ +The `Default` trait was derived on an enum. + +Erroneous code example: + +```compile_fail,E0665 +#[derive(Default)] +enum Food { + Sweet, + Salty, +} +``` + +The `Default` cannot be derived on an enum for the simple reason that the +compiler doesn't know which value to pick by default whereas it can for a +struct as long as all its fields implement the `Default` trait as well. + +If you still want to implement `Default` on your enum, you'll have to do it "by +hand": + +``` +enum Food { + Sweet, + Salty, +} + +impl Default for Food { + fn default() -> Food { + Food::Sweet + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0666.md b/src/librustc_error_codes/error_codes/E0666.md new file mode 100644 index 00000000000..22133683dc5 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0666.md @@ -0,0 +1,21 @@ +`impl Trait` types cannot appear nested in the +generic arguments of other `impl Trait` types. + +Example of erroneous code: + +```compile_fail,E0666 +trait MyGenericTrait<T> {} +trait MyInnerTrait {} + +fn foo(bar: impl MyGenericTrait<impl MyInnerTrait>) {} +``` + +Type parameters for `impl Trait` types must be +explicitly defined as named generic parameters: + +``` +trait MyGenericTrait<T> {} +trait MyInnerTrait {} + +fn foo<T: MyInnerTrait>(bar: impl MyGenericTrait<T>) {} +``` diff --git a/src/librustc_error_codes/error_codes/E0668.md b/src/librustc_error_codes/error_codes/E0668.md new file mode 100644 index 00000000000..2621a31a9e0 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0668.md @@ -0,0 +1,19 @@ +Malformed inline assembly rejected by LLVM. + +LLVM checks the validity of the constraints and the assembly string passed to +it. This error implies that LLVM seems something wrong with the inline +assembly call. + +In particular, it can happen if you forgot the closing bracket of a register +constraint (see issue #51430): +```ignore (error-emitted-at-codegen-which-cannot-be-handled-by-compile_fail) +#![feature(asm)] + +fn main() { + let rax: u64; + unsafe { + asm!("" :"={rax"(rax)); + println!("Accumulator is: {}", rax); + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0669.md b/src/librustc_error_codes/error_codes/E0669.md new file mode 100644 index 00000000000..39de01eebe8 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0669.md @@ -0,0 +1,8 @@ +Cannot convert inline assembly operand to a single LLVM value. + +This error usually happens when trying to pass in a value to an input inline +assembly operand that is actually a pair of values. In particular, this can +happen when trying to pass in a slice, for instance a `&str`. In Rust, these +values are represented internally as a pair of values, the pointer and its +length. When passed as an input operand, this pair of values can not be +coerced into a register and thus we must fail with an error. diff --git a/src/librustc_error_codes/error_codes/E0670.md b/src/librustc_error_codes/error_codes/E0670.md new file mode 100644 index 00000000000..2026370bec3 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0670.md @@ -0,0 +1,9 @@ +Rust 2015 does not permit the use of `async fn`. + +Example of erroneous code: + +```compile_fail,E0670 +async fn foo() {} +``` + +Switch to the Rust 2018 edition to use `async fn`. diff --git a/src/librustc_error_codes/error_codes/E0671.md b/src/librustc_error_codes/error_codes/E0671.md new file mode 100644 index 00000000000..449fb8ffc89 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0671.md @@ -0,0 +1,12 @@ +#### Note: this error code is no longer emitted by the compiler. + +Const parameters cannot depend on type parameters. +The following is therefore invalid: + +```compile_fail,E0741 +#![feature(const_generics)] + +fn const_id<T, const N: T>() -> T { // error + N +} +``` diff --git a/src/librustc_error_codes/error_codes/E0689.md b/src/librustc_error_codes/error_codes/E0689.md new file mode 100644 index 00000000000..26c2c15ccfa --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0689.md @@ -0,0 +1,26 @@ +This error indicates that the numeric value for the method being passed exists +but the type of the numeric value or binding could not be identified. + +The error happens on numeric literals: + +```compile_fail,E0689 +2.0.neg(); +``` + +and on numeric bindings without an identified concrete type: + +```compile_fail,E0689 +let x = 2.0; +x.neg(); // same error as above +``` + +Because of this, you must give the numeric literal or binding a type: + +``` +use std::ops::Neg; + +let _ = 2.0_f32.neg(); +let x: f32 = 2.0; +let _ = x.neg(); +let _ = (2.0 as f32).neg(); +``` diff --git a/src/librustc_error_codes/error_codes/E0690.md b/src/librustc_error_codes/error_codes/E0690.md new file mode 100644 index 00000000000..3a4d1c56fad --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0690.md @@ -0,0 +1,33 @@ +A struct with the representation hint `repr(transparent)` had zero or more than +one fields that were not guaranteed to be zero-sized. + +Erroneous code example: + +```compile_fail,E0690 +#[repr(transparent)] +struct LengthWithUnit<U> { // error: transparent struct needs exactly one + value: f32, // non-zero-sized field, but has 2 + unit: U, +} +``` + +Because transparent structs are represented exactly like one of their fields at +run time, said field must be uniquely determined. If there is no field, or if +there are multiple fields, it is not clear how the struct should be represented. +Note that fields of zero-typed types (e.g., `PhantomData`) can also exist +alongside the field that contains the actual data, they do not count for this +error. When generic types are involved (as in the above example), an error is +reported because the type parameter could be non-zero-sized. + +To combine `repr(transparent)` with type parameters, `PhantomData` may be +useful: + +``` +use std::marker::PhantomData; + +#[repr(transparent)] +struct LengthWithUnit<U> { + value: f32, + unit: PhantomData<U>, +} +``` diff --git a/src/librustc_error_codes/error_codes/E0691.md b/src/librustc_error_codes/error_codes/E0691.md new file mode 100644 index 00000000000..60060cacbd6 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0691.md @@ -0,0 +1,48 @@ +A struct, enum, or union with the `repr(transparent)` representation hint +contains a zero-sized field that requires non-trivial alignment. + +Erroneous code example: + +```compile_fail,E0691 +#![feature(repr_align)] + +#[repr(align(32))] +struct ForceAlign32; + +#[repr(transparent)] +struct Wrapper(f32, ForceAlign32); // error: zero-sized field in transparent + // struct has alignment larger than 1 +``` + +A transparent struct, enum, or union is supposed to be represented exactly like +the piece of data it contains. Zero-sized fields with different alignment +requirements potentially conflict with this property. In the example above, +`Wrapper` would have to be aligned to 32 bytes even though `f32` has a smaller +alignment requirement. + +Consider removing the over-aligned zero-sized field: + +``` +#[repr(transparent)] +struct Wrapper(f32); +``` + +Alternatively, `PhantomData<T>` has alignment 1 for all `T`, so you can use it +if you need to keep the field for some reason: + +``` +#![feature(repr_align)] + +use std::marker::PhantomData; + +#[repr(align(32))] +struct ForceAlign32; + +#[repr(transparent)] +struct Wrapper(f32, PhantomData<ForceAlign32>); +``` + +Note that empty arrays `[T; 0]` have the same alignment requirement as the +element type `T`. Also note that the error is conservatively reported even when +the alignment of the zero-sized type is less than or equal to the data field's +alignment. diff --git a/src/librustc_error_codes/error_codes/E0692.md b/src/librustc_error_codes/error_codes/E0692.md new file mode 100644 index 00000000000..596cb1e777e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0692.md @@ -0,0 +1,49 @@ +A `repr(transparent)` type was also annotated with other, incompatible +representation hints. + +Erroneous code example: + +```compile_fail,E0692 +#[repr(transparent, C)] // error: incompatible representation hints +struct Grams(f32); +``` + +A type annotated as `repr(transparent)` delegates all representation concerns to +another type, so adding more representation hints is contradictory. Remove +either the `transparent` hint or the other hints, like this: + +``` +#[repr(transparent)] +struct Grams(f32); +``` + +Alternatively, move the other attributes to the contained type: + +``` +#[repr(C)] +struct Foo { + x: i32, + // ... +} + +#[repr(transparent)] +struct FooWrapper(Foo); +``` + +Note that introducing another `struct` just to have a place for the other +attributes may have unintended side effects on the representation: + +``` +#[repr(transparent)] +struct Grams(f32); + +#[repr(C)] +struct Float(f32); + +#[repr(transparent)] +struct Grams2(Float); // this is not equivalent to `Grams` above +``` + +Here, `Grams2` is a not equivalent to `Grams` -- the former transparently wraps +a (non-transparent) struct containing a single float, while `Grams` is a +transparent wrapper around a float. This can make a difference for the ABI. diff --git a/src/librustc_error_codes/error_codes/E0695.md b/src/librustc_error_codes/error_codes/E0695.md new file mode 100644 index 00000000000..208f7f4c7b1 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0695.md @@ -0,0 +1,35 @@ +A `break` statement without a label appeared inside a labeled block. + +Example of erroneous code: + +```compile_fail,E0695 +# #![feature(label_break_value)] +loop { + 'a: { + break; + } +} +``` + +Make sure to always label the `break`: + +``` +# #![feature(label_break_value)] +'l: loop { + 'a: { + break 'l; + } +} +``` + +Or if you want to `break` the labeled block: + +``` +# #![feature(label_break_value)] +loop { + 'a: { + break 'a; + } + break; +} +``` diff --git a/src/librustc_error_codes/error_codes/E0697.md b/src/librustc_error_codes/error_codes/E0697.md new file mode 100644 index 00000000000..ab63d2e73f7 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0697.md @@ -0,0 +1,15 @@ +A closure has been used as `static`. + +Erroneous code example: + +```compile_fail,E0697 +fn main() { + static || {}; // used as `static` +} +``` + +Closures cannot be used as `static`. They "save" the environment, +and as such a static closure would save only a static environment +which would consist only of variables with a static lifetime. Given +this it would be better to use a proper function. The easiest fix +is to remove the `static` keyword. diff --git a/src/librustc_error_codes/error_codes/E0698.md b/src/librustc_error_codes/error_codes/E0698.md new file mode 100644 index 00000000000..d0fcec39902 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0698.md @@ -0,0 +1,25 @@ +When using generators (or async) all type variables must be bound so a +generator can be constructed. + +Erroneous code example: + +```edition2018,compile-fail,E0698 +async fn bar<T>() -> () {} + +async fn foo() { + bar().await; // error: cannot infer type for `T` +} +``` + +In the above example `T` is unknowable by the compiler. +To fix this you must bind `T` to a concrete type such as `String` +so that a generator can then be constructed: + +```edition2018 +async fn bar<T>() -> () {} + +async fn foo() { + bar::<String>().await; + // ^^^^^^^^ specify type explicitly +} +``` diff --git a/src/librustc_error_codes/error_codes/E0699.md b/src/librustc_error_codes/error_codes/E0699.md new file mode 100644 index 00000000000..f90fd3b5624 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0699.md @@ -0,0 +1,44 @@ +A method was called on a raw pointer whose inner type wasn't completely known. + +For example, you may have done something like: + +```compile_fail +# #![deny(warnings)] +let foo = &1; +let bar = foo as *const _; +if bar.is_null() { + // ... +} +``` + +Here, the type of `bar` isn't known; it could be a pointer to anything. Instead, +specify a type for the pointer (preferably something that makes sense for the +thing you're pointing to): + +``` +let foo = &1; +let bar = foo as *const i32; +if bar.is_null() { + // ... +} +``` + +Even though `is_null()` exists as a method on any raw pointer, Rust shows this +error because Rust allows for `self` to have arbitrary types (behind the +arbitrary_self_types feature flag). + +This means that someone can specify such a function: + +```ignore (cannot-doctest-feature-doesnt-exist-yet) +impl Foo { + fn is_null(self: *const Self) -> bool { + // do something else + } +} +``` + +and now when you call `.is_null()` on a raw pointer to `Foo`, there's ambiguity. + +Given that we don't know what type the pointer is, and there's potential +ambiguity for some types, we disallow calling methods on raw pointers when +the type is unknown. diff --git a/src/librustc_error_codes/error_codes/E0700.md b/src/librustc_error_codes/error_codes/E0700.md new file mode 100644 index 00000000000..41ac4d948c2 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0700.md @@ -0,0 +1,44 @@ +The `impl Trait` return type captures lifetime parameters that do not +appear within the `impl Trait` itself. + +Erroneous code example: + +```compile-fail,E0700 +use std::cell::Cell; + +trait Trait<'a> { } + +impl<'a, 'b> Trait<'b> for Cell<&'a u32> { } + +fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y> +where 'x: 'y +{ + x +} +``` + +Here, the function `foo` returns a value of type `Cell<&'x u32>`, +which references the lifetime `'x`. However, the return type is +declared as `impl Trait<'y>` -- this indicates that `foo` returns +"some type that implements `Trait<'y>`", but it also indicates that +the return type **only captures data referencing the lifetime `'y`**. +In this case, though, we are referencing data with lifetime `'x`, so +this function is in error. + +To fix this, you must reference the lifetime `'x` from the return +type. For example, changing the return type to `impl Trait<'y> + 'x` +would work: + +``` +use std::cell::Cell; + +trait Trait<'a> { } + +impl<'a,'b> Trait<'b> for Cell<&'a u32> { } + +fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y> + 'x +where 'x: 'y +{ + x +} +``` diff --git a/src/librustc_error_codes/error_codes/E0701.md b/src/librustc_error_codes/error_codes/E0701.md new file mode 100644 index 00000000000..87f416ada18 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0701.md @@ -0,0 +1,9 @@ +This error indicates that a `#[non_exhaustive]` attribute was incorrectly placed +on something other than a struct or enum. + +Examples of erroneous code: + +```compile_fail,E0701 +#[non_exhaustive] +trait Foo { } +``` diff --git a/src/librustc_error_codes/error_codes/E0704.md b/src/librustc_error_codes/error_codes/E0704.md new file mode 100644 index 00000000000..cde46f52c27 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0704.md @@ -0,0 +1,26 @@ +This error indicates that a incorrect visibility restriction was specified. + +Example of erroneous code: + +```compile_fail,E0704 +mod foo { + pub(foo) struct Bar { + x: i32 + } +} +``` + +To make struct `Bar` only visible in module `foo` the `in` keyword should be +used: +``` +mod foo { + pub(in crate::foo) struct Bar { + x: i32 + } +} +# fn main() {} +``` + +For more information see the Rust Reference on [Visibility]. + +[Visibility]: https://doc.rust-lang.org/reference/visibility-and-privacy.html diff --git a/src/librustc_error_codes/error_codes/E0705.md b/src/librustc_error_codes/error_codes/E0705.md new file mode 100644 index 00000000000..8fa09fe8e72 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0705.md @@ -0,0 +1,11 @@ +A `#![feature]` attribute was declared for a feature that is stable in +the current edition, but not in all editions. + +Erroneous code example: + +```ignore (limited to a warning during 2018 edition development) +#![feature(rust_2018_preview)] +#![feature(test_2018_feature)] // error: the feature + // `test_2018_feature` is + // included in the Rust 2018 edition +``` diff --git a/src/librustc_error_codes/error_codes/E0712.md b/src/librustc_error_codes/error_codes/E0712.md new file mode 100644 index 00000000000..89f60084f0a --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0712.md @@ -0,0 +1,19 @@ +This error occurs because a borrow of a thread-local variable was made inside a +function which outlived the lifetime of the function. + +Erroneous code example: + +```compile_fail,E0712 +#![feature(thread_local)] + +#[thread_local] +static FOO: u8 = 3; + +fn main() { + let a = &FOO; // error: thread-local variable borrowed past end of function + + std::thread::spawn(move || { + println!("{}", a); + }); +} +``` diff --git a/src/librustc_error_codes/error_codes/E0713.md b/src/librustc_error_codes/error_codes/E0713.md new file mode 100644 index 00000000000..9361046943f --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0713.md @@ -0,0 +1,51 @@ +This error occurs when an attempt is made to borrow state past the end of the +lifetime of a type that implements the `Drop` trait. + +Erroneous code example: + +```compile_fail,E0713 +#![feature(nll)] + +pub struct S<'a> { data: &'a mut String } + +impl<'a> Drop for S<'a> { + fn drop(&mut self) { self.data.push_str("being dropped"); } +} + +fn demo<'a>(s: S<'a>) -> &'a mut String { let p = &mut *s.data; p } +``` + +Here, `demo` tries to borrow the string data held within its +argument `s` and then return that borrow. However, `S` is +declared as implementing `Drop`. + +Structs implementing the `Drop` trait have an implicit destructor that +gets called when they go out of scope. This destructor gets exclusive +access to the fields of the struct when it runs. + +This means that when `s` reaches the end of `demo`, its destructor +gets exclusive access to its `&mut`-borrowed string data. allowing +another borrow of that string data (`p`), to exist across the drop of +`s` would be a violation of the principle that `&mut`-borrows have +exclusive, unaliased access to their referenced data. + +This error can be fixed by changing `demo` so that the destructor does +not run while the string-data is borrowed; for example by taking `S` +by reference: + +``` +pub struct S<'a> { data: &'a mut String } + +impl<'a> Drop for S<'a> { + fn drop(&mut self) { self.data.push_str("being dropped"); } +} + +fn demo<'a>(s: &'a mut S<'a>) -> &'a mut String { let p = &mut *(*s).data; p } +``` + +Note that this approach needs a reference to S with lifetime `'a`. +Nothing shorter than `'a` will suffice: a shorter lifetime would imply +that after `demo` finishes executing, something else (such as the +destructor!) could access `s.data` after the end of that shorter +lifetime, which would again violate the `&mut`-borrow's exclusive +access. diff --git a/src/librustc_error_codes/error_codes/E0714.md b/src/librustc_error_codes/error_codes/E0714.md new file mode 100644 index 00000000000..e8707f3e390 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0714.md @@ -0,0 +1,5 @@ +A `#[marker]` trait contained an associated item. + +The items of marker traits cannot be overridden, so there's no need to have them +when they cannot be changed per-type anyway. If you wanted them for ergonomic +reasons, consider making an extension trait instead. diff --git a/src/librustc_error_codes/error_codes/E0715.md b/src/librustc_error_codes/error_codes/E0715.md new file mode 100644 index 00000000000..9e20e813683 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0715.md @@ -0,0 +1,5 @@ +An `impl` for a `#[marker]` trait tried to override an associated item. + +Because marker traits are allowed to have multiple implementations for the same +type, it's not allowed to override anything in those implementations, as it +would be ambiguous which override should actually be used. diff --git a/src/librustc_error_codes/error_codes/E0716.md b/src/librustc_error_codes/error_codes/E0716.md new file mode 100644 index 00000000000..25567c1d128 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0716.md @@ -0,0 +1,82 @@ +This error indicates that a temporary value is being dropped +while a borrow is still in active use. + +Erroneous code example: + +```compile_fail,E0716 +fn foo() -> i32 { 22 } +fn bar(x: &i32) -> &i32 { x } +let p = bar(&foo()); + // ------ creates a temporary +let q = *p; +``` + +Here, the expression `&foo()` is borrowing the expression +`foo()`. As `foo()` is a call to a function, and not the name of +a variable, this creates a **temporary** -- that temporary stores +the return value from `foo()` so that it can be borrowed. +You could imagine that `let p = bar(&foo());` is equivalent +to this: + +```compile_fail,E0597 +# fn foo() -> i32 { 22 } +# fn bar(x: &i32) -> &i32 { x } +let p = { + let tmp = foo(); // the temporary + bar(&tmp) +}; // <-- tmp is freed as we exit this block +let q = p; +``` + +Whenever a temporary is created, it is automatically dropped (freed) +according to fixed rules. Ordinarily, the temporary is dropped +at the end of the enclosing statement -- in this case, after the `let`. +This is illustrated in the example above by showing that `tmp` would +be freed as we exit the block. + +To fix this problem, you need to create a local variable +to store the value in rather than relying on a temporary. +For example, you might change the original program to +the following: + +``` +fn foo() -> i32 { 22 } +fn bar(x: &i32) -> &i32 { x } +let value = foo(); // dropped at the end of the enclosing block +let p = bar(&value); +let q = *p; +``` + +By introducing the explicit `let value`, we allocate storage +that will last until the end of the enclosing block (when `value` +goes out of scope). When we borrow `&value`, we are borrowing a +local variable that already exists, and hence no temporary is created. + +Temporaries are not always dropped at the end of the enclosing +statement. In simple cases where the `&` expression is immediately +stored into a variable, the compiler will automatically extend +the lifetime of the temporary until the end of the enclosing +block. Therefore, an alternative way to fix the original +program is to write `let tmp = &foo()` and not `let tmp = foo()`: + +``` +fn foo() -> i32 { 22 } +fn bar(x: &i32) -> &i32 { x } +let value = &foo(); +let p = bar(value); +let q = *p; +``` + +Here, we are still borrowing `foo()`, but as the borrow is assigned +directly into a variable, the temporary will not be dropped until +the end of the enclosing block. Similar rules apply when temporaries +are stored into aggregate structures like a tuple or struct: + +``` +// Here, two temporaries are created, but +// as they are stored directly into `value`, +// they are not dropped until the end of the +// enclosing block. +fn foo() -> i32 { 22 } +let value = (&foo(), &foo()); +``` diff --git a/src/librustc_error_codes/error_codes/E0718.md b/src/librustc_error_codes/error_codes/E0718.md new file mode 100644 index 00000000000..8548ff0c150 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0718.md @@ -0,0 +1,11 @@ +This error indicates that a `#[lang = ".."]` attribute was placed +on the wrong type of item. + +Examples of erroneous code: + +```compile_fail,E0718 +#![feature(lang_items)] + +#[lang = "arc"] +static X: u32 = 42; +``` diff --git a/src/librustc_error_codes/error_codes/E0720.md b/src/librustc_error_codes/error_codes/E0720.md new file mode 100644 index 00000000000..410aa4f4609 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0720.md @@ -0,0 +1,11 @@ +An `impl Trait` type expands to a recursive type. + +An `impl Trait` type must be expandable to a concrete type that contains no +`impl Trait` types. For example the following example tries to create an +`impl Trait` type `T` that is equal to `[T, T]`: + +```compile_fail,E0720 +fn make_recursive_type() -> impl Sized { + [make_recursive_type(), make_recursive_type()] +} +``` diff --git a/src/librustc_error_codes/error_codes/E0723.md b/src/librustc_error_codes/error_codes/E0723.md new file mode 100644 index 00000000000..394ee057b0b --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0723.md @@ -0,0 +1,28 @@ +An feature unstable in `const` contexts was used. + +Erroneous code example: + +```compile_fail,E0723 +trait T {} + +impl T for () {} + +const fn foo() -> impl T { // error: `impl Trait` in const fn is unstable + () +} +``` + +To enable this feature on a nightly version of rustc, add the `const_fn` +feature flag: + +``` +#![feature(const_fn)] + +trait T {} + +impl T for () {} + +const fn foo() -> impl T { + () +} +``` diff --git a/src/librustc_error_codes/error_codes/E0725.md b/src/librustc_error_codes/error_codes/E0725.md new file mode 100644 index 00000000000..9bd321e5f82 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0725.md @@ -0,0 +1,12 @@ +A feature attribute named a feature that was disallowed in the compiler +command line flags. + +Erroneous code example: + +```ignore (can't specify compiler flags from doctests) +#![feature(never_type)] // error: the feature `never_type` is not in + // the list of allowed features +``` + +Delete the offending feature attribute, or add it to the list of allowed +features in the `-Z allow_features` flag. diff --git a/src/librustc_error_codes/error_codes/E0728.md b/src/librustc_error_codes/error_codes/E0728.md new file mode 100644 index 00000000000..1afbedab0ca --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0728.md @@ -0,0 +1,75 @@ +[`await`] has been used outside [`async`] function or block. + +Erroneous code examples: + +```edition2018,compile_fail,E0728 +# use std::pin::Pin; +# use std::future::Future; +# use std::task::{Context, Poll}; +# +# struct WakeOnceThenComplete(bool); +# +# fn wake_and_yield_once() -> WakeOnceThenComplete { +# WakeOnceThenComplete(false) +# } +# +# impl Future for WakeOnceThenComplete { +# type Output = (); +# fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> { +# if self.0 { +# Poll::Ready(()) +# } else { +# cx.waker().wake_by_ref(); +# self.0 = true; +# Poll::Pending +# } +# } +# } +# +fn foo() { + wake_and_yield_once().await // `await` is used outside `async` context +} +``` + +[`await`] is used to suspend the current computation until the given +future is ready to produce a value. So it is legal only within +an [`async`] context, like an `async fn` or an `async` block. + +```edition2018 +# use std::pin::Pin; +# use std::future::Future; +# use std::task::{Context, Poll}; +# +# struct WakeOnceThenComplete(bool); +# +# fn wake_and_yield_once() -> WakeOnceThenComplete { +# WakeOnceThenComplete(false) +# } +# +# impl Future for WakeOnceThenComplete { +# type Output = (); +# fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> { +# if self.0 { +# Poll::Ready(()) +# } else { +# cx.waker().wake_by_ref(); +# self.0 = true; +# Poll::Pending +# } +# } +# } +# +async fn foo() { + wake_and_yield_once().await // `await` is used within `async` function +} + +fn bar(x: u8) -> impl Future<Output = u8> { + async move { + wake_and_yield_once().await; // `await` is used within `async` block + x + } +} +``` + +[`async`]: https://doc.rust-lang.org/std/keyword.async.html +[`await`]: https://doc.rust-lang.org/std/keyword.await.html diff --git a/src/librustc_error_codes/error_codes/E0729.md b/src/librustc_error_codes/error_codes/E0729.md new file mode 100644 index 00000000000..74f89080b91 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0729.md @@ -0,0 +1,30 @@ +Support for Non-Lexical Lifetimes (NLL) has been included in the Rust compiler +since 1.31, and has been enabled on the 2015 edition since 1.36. The new borrow +checker for NLL uncovered some bugs in the old borrow checker, which in some +cases allowed unsound code to compile, resulting in memory safety issues. + +### What do I do? + +Change your code so the warning does no longer trigger. For backwards +compatibility, this unsound code may still compile (with a warning) right now. +However, at some point in the future, the compiler will no longer accept this +code and will throw a hard error. + +### Shouldn't you fix the old borrow checker? + +The old borrow checker has known soundness issues that are basically impossible +to fix. The new NLL-based borrow checker is the fix. + +### Can I turn these warnings into errors by denying a lint? + +No. + +### When are these warnings going to turn into errors? + +No formal timeline for turning the warnings into errors has been set. See +[GitHub issue 58781](https://github.com/rust-lang/rust/issues/58781) for more +information. + +### Why do I get this message with code that doesn't involve borrowing? + +There are some known bugs that trigger this message. diff --git a/src/librustc_error_codes/error_codes/E0730.md b/src/librustc_error_codes/error_codes/E0730.md new file mode 100644 index 00000000000..803a2514865 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0730.md @@ -0,0 +1,29 @@ +An array without a fixed length was pattern-matched. + +Example of erroneous code: + +```compile_fail,E0730 +#![feature(const_generics)] + +fn is_123<const N: usize>(x: [u32; N]) -> bool { + match x { + [1, 2, 3] => true, // error: cannot pattern-match on an + // array without a fixed length + _ => false + } +} +``` + +Ensure that the pattern is consistent with the size of the matched +array. Additional elements can be matched with `..`: + +``` +#![feature(slice_patterns)] + +let r = &[1, 2, 3, 4]; +match r { + &[a, b, ..] => { // ok! + println!("a={}, b={}", a, b); + } +} +``` diff --git a/src/librustc_error_codes/error_codes/E0731.md b/src/librustc_error_codes/error_codes/E0731.md new file mode 100644 index 00000000000..096c053fe83 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0731.md @@ -0,0 +1,17 @@ +An enum with the representation hint `repr(transparent)` had zero or more than +one variants. + +Erroneous code example: + +```compile_fail,E0731 +#[repr(transparent)] +enum Status { // error: transparent enum needs exactly one variant, but has 2 + Errno(u32), + Ok, +} +``` + +Because transparent enums are represented exactly like one of their variants at +run time, said variant must be uniquely determined. If there is no variant, or +if there are multiple variants, it is not clear how the enum should be +represented. diff --git a/src/librustc_error_codes/error_codes/E0732.md b/src/librustc_error_codes/error_codes/E0732.md new file mode 100644 index 00000000000..03137590e88 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0732.md @@ -0,0 +1,29 @@ +An `enum` with a discriminant must specify a `#[repr(inttype)]`. + +A `#[repr(inttype)]` must be provided on an `enum` if it has a non-unit +variant with a discriminant, or where there are both unit variants with +discriminants and non-unit variants. This restriction ensures that there +is a well-defined way to extract a variant's discriminant from a value; +for instance: + +``` +#![feature(arbitrary_enum_discriminant)] + +#[repr(u8)] +enum Enum { + Unit = 3, + Tuple(u16) = 2, + Struct { + a: u8, + b: u16, + } = 1, +} + +fn discriminant(v : &Enum) -> u8 { + unsafe { *(v as *const Enum as *const u8) } +} + +assert_eq!(3, discriminant(&Enum::Unit)); +assert_eq!(2, discriminant(&Enum::Tuple(5))); +assert_eq!(1, discriminant(&Enum::Struct{a: 7, b: 11})); +``` diff --git a/src/librustc_error_codes/error_codes/E0733.md b/src/librustc_error_codes/error_codes/E0733.md new file mode 100644 index 00000000000..0bda7a7d682 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0733.md @@ -0,0 +1,40 @@ +Recursion in an `async fn` requires boxing. For example, this will not compile: + +```edition2018,compile_fail,E0733 +async fn foo(n: usize) { + if n > 0 { + foo(n - 1).await; + } +} +``` + +To achieve async recursion, the `async fn` needs to be desugared +such that the `Future` is explicit in the return type: + +```edition2018,compile_fail,E0720 +use std::future::Future; +fn foo_desugared(n: usize) -> impl Future<Output = ()> { + async move { + if n > 0 { + foo_desugared(n - 1).await; + } + } +} +``` + +Finally, the future is wrapped in a pinned box: + +```edition2018 +use std::future::Future; +use std::pin::Pin; +fn foo_recursive(n: usize) -> Pin<Box<dyn Future<Output = ()>>> { + Box::pin(async move { + if n > 0 { + foo_recursive(n - 1).await; + } + }) +} +``` + +The `Box<...>` ensures that the result is of known size, +and the pin is required to keep it in the same place in memory. diff --git a/src/librustc_error_codes/error_codes/E0734.md b/src/librustc_error_codes/error_codes/E0734.md new file mode 100644 index 00000000000..913801d2236 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0734.md @@ -0,0 +1,13 @@ +A stability attribute has been used outside of the standard library. + +Erroneous code examples: + +```compile_fail,E0734 +#[rustc_deprecated(since = "b", reason = "text")] // invalid +#[stable(feature = "a", since = "b")] // invalid +#[unstable(feature = "b", issue = "0")] // invalid +fn foo(){} +``` + +These attributes are meant to only be used by the standard library and are +rejected in your own crates. diff --git a/src/librustc_error_codes/error_codes/E0735.md b/src/librustc_error_codes/error_codes/E0735.md new file mode 100644 index 00000000000..e8268a5836c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0735.md @@ -0,0 +1,11 @@ +Type parameter defaults cannot use `Self` on structs, enums, or unions. + +Erroneous code example: + +```compile_fail,E0735 +struct Foo<X = Box<Self>> { + field1: Option<X>, + field2: Option<X>, +} +// error: type parameters cannot use `Self` in their defaults. +``` diff --git a/src/librustc_error_codes/error_codes/E0736.md b/src/librustc_error_codes/error_codes/E0736.md new file mode 100644 index 00000000000..8a60dc32059 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0736.md @@ -0,0 +1,16 @@ +`#[track_caller]` and `#[naked]` cannot both be applied to the same function. + +Erroneous code example: + +```compile_fail,E0736 +#![feature(track_caller)] + +#[naked] +#[track_caller] +fn foo() {} +``` + +This is primarily due to ABI incompatibilities between the two attributes. +See [RFC 2091] for details on this and other limitations. + +[RFC 2091]: https://github.com/rust-lang/rfcs/blob/master/text/2091-inline-semantic.md diff --git a/src/librustc_error_codes/error_codes/E0737.md b/src/librustc_error_codes/error_codes/E0737.md new file mode 100644 index 00000000000..c6553e97b7e --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0737.md @@ -0,0 +1,14 @@ +`#[track_caller]` requires functions to have the `"Rust"` ABI for implicitly +receiving caller location. See [RFC 2091] for details on this and other +restrictions. + +Erroneous code example: + +```compile_fail,E0737 +#![feature(track_caller)] + +#[track_caller] +extern "C" fn foo() {} +``` + +[RFC 2091]: https://github.com/rust-lang/rfcs/blob/master/text/2091-inline-semantic.md diff --git a/src/librustc_error_codes/error_codes/E0738.md b/src/librustc_error_codes/error_codes/E0738.md new file mode 100644 index 00000000000..4c9588ef7b6 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0738.md @@ -0,0 +1,48 @@ +`#[track_caller]` cannot be used in traits yet. This is due to limitations in +the compiler which are likely to be temporary. See [RFC 2091] for details on +this and other restrictions. + +Erroneous example with a trait method implementation: + +```compile_fail,E0738 +#![feature(track_caller)] + +trait Foo { + fn bar(&self); +} + +impl Foo for u64 { + #[track_caller] + fn bar(&self) {} +} +``` + +Erroneous example with a blanket trait method implementation: + +```compile_fail,E0738 +#![feature(track_caller)] + +trait Foo { + #[track_caller] + fn bar(&self) {} + fn baz(&self); +} +``` + +Erroneous example with a trait method declaration: + +```compile_fail,E0738 +#![feature(track_caller)] + +trait Foo { + fn bar(&self) {} + + #[track_caller] + fn baz(&self); +} +``` + +Note that while the compiler may be able to support the attribute in traits in +the future, [RFC 2091] prohibits their implementation without a follow-up RFC. + +[RFC 2091]: https://github.com/rust-lang/rfcs/blob/master/text/2091-inline-semantic.md diff --git a/src/librustc_error_codes/error_codes/E0740.md b/src/librustc_error_codes/error_codes/E0740.md new file mode 100644 index 00000000000..a9eb5f2790d --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0740.md @@ -0,0 +1 @@ +A `union` cannot have fields with destructors. diff --git a/src/librustc_error_codes/error_codes/E0741.md b/src/librustc_error_codes/error_codes/E0741.md new file mode 100644 index 00000000000..804260809e9 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0741.md @@ -0,0 +1,21 @@ +Only `structural_match` types (that is, types that derive `PartialEq` and `Eq`) +may be used as the types of const generic parameters. + +```compile_fail,E0741 +#![feature(const_generics)] + +struct A; + +struct B<const X: A>; // error! +``` + +To fix this example, we derive `PartialEq` and `Eq`. + +``` +#![feature(const_generics)] + +#[derive(PartialEq, Eq)] +struct A; + +struct B<const X: A>; // ok! +``` diff --git a/src/librustc_error_codes/error_codes/E0742.md b/src/librustc_error_codes/error_codes/E0742.md new file mode 100644 index 00000000000..fed9f1f4cee --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0742.md @@ -0,0 +1,35 @@ +Visibility is restricted to a module which isn't an ancestor of the current +item. + +Erroneous code example: + +```compile_fail,E0742,edition2018 +pub mod Sea {} + +pub (in crate::Sea) struct Shark; // error! + +fn main() {} +``` + +To fix this error, we need to move the `Shark` struct inside the `Sea` module: + +```edition2018 +pub mod Sea { + pub (in crate::Sea) struct Shark; // ok! +} + +fn main() {} +``` + +Of course, you can do it as long as the module you're referring to is an +ancestor: + +```edition2018 +pub mod Earth { + pub mod Sea { + pub (in crate::Earth) struct Shark; // ok! + } +} + +fn main() {} +``` diff --git a/src/librustc_error_codes/error_codes/E0743.md b/src/librustc_error_codes/error_codes/E0743.md new file mode 100644 index 00000000000..aaf19d8478c --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0743.md @@ -0,0 +1,11 @@ +C-variadic has been used on a non-foreign function. + +Erroneous code example: + +```compile_fail,E0743 +fn foo2(x: u8, ...) {} // error! +``` + +Only foreign functions can use C-variadic (`...`). It is used to give an +undefined number of parameters to a given function (like `printf` in C). The +equivalent in Rust would be to use macros directly. diff --git a/src/librustc_error_codes/error_codes/E0744.md b/src/librustc_error_codes/error_codes/E0744.md new file mode 100644 index 00000000000..254223f3565 --- /dev/null +++ b/src/librustc_error_codes/error_codes/E0744.md @@ -0,0 +1,17 @@ +Control-flow expressions are not allowed inside a const context. + +At the moment, `if` and `match`, as well as the looping constructs `for`, +`while`, and `loop`, are forbidden inside a `const`, `static`, or `const fn`. + +```compile_fail,E0744 +const _: i32 = { + let mut x = 0; + loop { + x += 1; + if x == 4 { + break; + } + } + x +}; +``` diff --git a/src/librustc_error_codes/lib.rs b/src/librustc_error_codes/lib.rs new file mode 100644 index 00000000000..36b1518c869 --- /dev/null +++ b/src/librustc_error_codes/lib.rs @@ -0,0 +1,26 @@ +//! This library is used to gather all error codes into one place. The goal +//! being to make their maintenance easier. + +#[macro_export] +macro_rules! register_diagnostics { + ($($ecode:ident: $message:expr,)*) => ( + $crate::register_diagnostics!{$($ecode:$message,)* ;} + ); + + ($($ecode:ident: $message:expr,)* ; $($code:ident,)*) => ( + pub static DIAGNOSTICS: &[(&str, &str)] = &[ + $( (stringify!($ecode), $message), )* + ]; + + $( + pub const $ecode: &str = $message; + )* + $( + pub const $code: () = (); + )* + ) +} + +mod error_codes; + +pub use error_codes::*; diff --git a/src/librustc_interface/Cargo.toml b/src/librustc_interface/Cargo.toml index de59882bbdf..b16cfe9efa7 100644 --- a/src/librustc_interface/Cargo.toml +++ b/src/librustc_interface/Cargo.toml @@ -34,6 +34,7 @@ rustc_errors = { path = "../librustc_errors" } rustc_plugin = { path = "../librustc_plugin", package = "rustc_plugin_impl" } rustc_privacy = { path = "../librustc_privacy" } rustc_resolve = { path = "../librustc_resolve" } +rustc_error_codes = { path = "../librustc_error_codes" } tempfile = "3.0.5" once_cell = "1" diff --git a/src/librustc_interface/util.rs b/src/librustc_interface/util.rs index 6b9d708cefa..a5653a21b31 100644 --- a/src/librustc_interface/util.rs +++ b/src/librustc_interface/util.rs @@ -14,12 +14,8 @@ use rustc_data_structures::thin_vec::ThinVec; use rustc_data_structures::fx::{FxHashSet, FxHashMap}; use rustc_errors::registry::Registry; use rustc_metadata::dynamic_lib::DynamicLibrary; -use rustc_mir; -use rustc_passes; -use rustc_plugin; -use rustc_privacy; use rustc_resolve::{self, Resolver}; -use rustc_typeck; +use rustc_error_codes; use std::env; use std::env::consts::{DLL_PREFIX, DLL_SUFFIX}; use std::io::{self, Write}; @@ -43,18 +39,9 @@ use std::{thread, panic}; pub fn diagnostics_registry() -> Registry { let mut all_errors = Vec::new(); - all_errors.extend_from_slice(&rustc::error_codes::DIAGNOSTICS); - all_errors.extend_from_slice(&rustc_typeck::error_codes::DIAGNOSTICS); - all_errors.extend_from_slice(&rustc_resolve::error_codes::DIAGNOSTICS); - all_errors.extend_from_slice(&rustc_privacy::error_codes::DIAGNOSTICS); + all_errors.extend_from_slice(&rustc_error_codes::DIAGNOSTICS); // FIXME: need to figure out a way to get these back in here // all_errors.extend_from_slice(get_codegen_backend(sess).diagnostics()); - all_errors.extend_from_slice(&rustc_metadata::error_codes::DIAGNOSTICS); - all_errors.extend_from_slice(&rustc_parse::error_codes::DIAGNOSTICS); - all_errors.extend_from_slice(&rustc_passes::error_codes::DIAGNOSTICS); - all_errors.extend_from_slice(&rustc_plugin::error_codes::DIAGNOSTICS); - all_errors.extend_from_slice(&rustc_mir::error_codes::DIAGNOSTICS); - all_errors.extend_from_slice(&syntax::error_codes::DIAGNOSTICS); Registry::new(&all_errors) } diff --git a/src/librustc_lint/Cargo.toml b/src/librustc_lint/Cargo.toml index a61a314d549..d26d8791f66 100644 --- a/src/librustc_lint/Cargo.toml +++ b/src/librustc_lint/Cargo.toml @@ -16,3 +16,4 @@ syntax = { path = "../libsyntax" } syntax_pos = { path = "../libsyntax_pos" } rustc_data_structures = { path = "../librustc_data_structures" } rustc_index = { path = "../librustc_index" } +rustc_error_codes = { path = "../librustc_error_codes" } diff --git a/src/librustc_lint/error_codes.rs b/src/librustc_lint/error_codes.rs deleted file mode 100644 index 2edc8fadf45..00000000000 --- a/src/librustc_lint/error_codes.rs +++ /dev/null @@ -1,4 +0,0 @@ -syntax::register_diagnostics! { -; -// E0721, // `await` keyword -} diff --git a/src/librustc_lint/lib.rs b/src/librustc_lint/lib.rs index a1e50018f8a..7e8dc1d1679 100644 --- a/src/librustc_lint/lib.rs +++ b/src/librustc_lint/lib.rs @@ -23,7 +23,6 @@ extern crate rustc; mod array_into_iter; -mod error_codes; mod nonstandard_style; mod redundant_semicolon; pub mod builtin; diff --git a/src/librustc_metadata/Cargo.toml b/src/librustc_metadata/Cargo.toml index b1431563f21..b70cc529386 100644 --- a/src/librustc_metadata/Cargo.toml +++ b/src/librustc_metadata/Cargo.toml @@ -25,3 +25,4 @@ syntax = { path = "../libsyntax" } syntax_expand = { path = "../libsyntax_expand" } rustc_parse = { path = "../librustc_parse" } syntax_pos = { path = "../libsyntax_pos" } +rustc_error_codes = { path = "../librustc_error_codes" } diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs index b4dea19d3dc..6dfb2409775 100644 --- a/src/librustc_metadata/creader.rs +++ b/src/librustc_metadata/creader.rs @@ -32,6 +32,8 @@ use syntax_pos::{Span, DUMMY_SP}; use log::{debug, info, log_enabled}; use proc_macro::bridge::client::ProcMacro; +use rustc_error_codes::*; + crate struct Library { pub source: CrateSource, pub metadata: MetadataBlob, diff --git a/src/librustc_metadata/error_codes.rs b/src/librustc_metadata/error_codes.rs deleted file mode 100644 index cd8e95e6c3a..00000000000 --- a/src/librustc_metadata/error_codes.rs +++ /dev/null @@ -1,97 +0,0 @@ -syntax::register_diagnostics! { -E0454: r##" -A link name was given with an empty name. Erroneous code example: - -```ignore (cannot-test-this-because-rustdoc-stops-compile-fail-before-codegen) -#[link(name = "")] extern {} -// error: `#[link(name = "")]` given with empty name -``` - -The rust compiler cannot link to an external library if you don't give it its -name. Example: - -```no_run -#[link(name = "some_lib")] extern {} // ok! -``` -"##, - -E0455: r##" -Linking with `kind=framework` is only supported when targeting macOS, -as frameworks are specific to that operating system. - -Erroneous code example: - -```ignore (should-compile_fail-but-cannot-doctest-conditionally-without-macos) -#[link(name = "FooCoreServices", kind = "framework")] extern {} -// OS used to compile is Linux for example -``` - -To solve this error you can use conditional compilation: - -``` -#[cfg_attr(target="macos", link(name = "FooCoreServices", kind = "framework"))] -extern {} -``` - -See more: -https://doc.rust-lang.org/reference/attributes.html#conditional-compilation -"##, - -E0458: r##" -An unknown "kind" was specified for a link attribute. Erroneous code example: - -```ignore (cannot-test-this-because-rustdoc-stops-compile-fail-before-codegen) -#[link(kind = "wonderful_unicorn")] extern {} -// error: unknown kind: `wonderful_unicorn` -``` - -Please specify a valid "kind" value, from one of the following: - -* static -* dylib -* framework - -"##, - -E0459: r##" -A link was used without a name parameter. Erroneous code example: - -```ignore (cannot-test-this-because-rustdoc-stops-compile-fail-before-codegen) -#[link(kind = "dylib")] extern {} -// error: `#[link(...)]` specified without `name = "foo"` -``` - -Please add the name parameter to allow the rust compiler to find the library -you want. Example: - -```no_run -#[link(kind = "dylib", name = "some_lib")] extern {} // ok! -``` -"##, - -E0463: r##" -A plugin/crate was declared but cannot be found. Erroneous code example: - -```compile_fail,E0463 -#![feature(plugin)] -#![plugin(cookie_monster)] // error: can't find crate for `cookie_monster` -extern crate cake_is_a_lie; // error: can't find crate for `cake_is_a_lie` -``` - -You need to link your code to the relevant crate in order to be able to use it -(through Cargo or the `-L` option of rustc example). Plugins are crates as -well, and you link to them the same way. -"##, -; - E0456, // plugin `..` is not available for triple `..` - E0457, // plugin `..` only found in rlib format, but must be available... - E0514, // metadata version mismatch - E0460, // found possibly newer version of crate `..` - E0461, // couldn't find crate `..` with expected target triple .. - E0462, // found staticlib `..` instead of rlib or dylib - E0464, // multiple matching crates for `..` - E0465, // multiple .. candidates for `..` found - E0519, // local crate and dependency have same (crate-name, disambiguator) - // two dependencies have same (crate-name, disambiguator) but different SVH - E0523, -} diff --git a/src/librustc_metadata/lib.rs b/src/librustc_metadata/lib.rs index ac9d78e9a51..35ac7686647 100644 --- a/src/librustc_metadata/lib.rs +++ b/src/librustc_metadata/lib.rs @@ -24,8 +24,6 @@ extern crate rustc; #[macro_use] extern crate rustc_data_structures; -pub mod error_codes; - mod dependency_format; mod foreign_modules; mod link_args; diff --git a/src/librustc_metadata/locator.rs b/src/librustc_metadata/locator.rs index 88d7595b063..582602138e5 100644 --- a/src/librustc_metadata/locator.rs +++ b/src/librustc_metadata/locator.rs @@ -246,6 +246,8 @@ use rustc_data_structures::owning_ref::OwningRef; use log::{debug, info, warn}; +use rustc_error_codes::*; + #[derive(Clone)] crate struct CrateMismatch { path: PathBuf, diff --git a/src/librustc_metadata/native_libs.rs b/src/librustc_metadata/native_libs.rs index c9de66a5c87..e577b238c86 100644 --- a/src/librustc_metadata/native_libs.rs +++ b/src/librustc_metadata/native_libs.rs @@ -11,6 +11,8 @@ use syntax::feature_gate::{self, GateIssue}; use syntax::symbol::{kw, sym, Symbol}; use syntax::{span_err, struct_span_err}; +use rustc_error_codes::*; + crate fn collect(tcx: TyCtxt<'_>) -> Vec<NativeLibrary> { let mut collector = Collector { tcx, diff --git a/src/librustc_mir/Cargo.toml b/src/librustc_mir/Cargo.toml index 8c62640353a..daa2617bd9e 100644 --- a/src/librustc_mir/Cargo.toml +++ b/src/librustc_mir/Cargo.toml @@ -27,3 +27,4 @@ syntax = { path = "../libsyntax" } syntax_pos = { path = "../libsyntax_pos" } rustc_apfloat = { path = "../librustc_apfloat" } smallvec = { version = "1.0", features = ["union", "may_dangle"] } +rustc_error_codes = { path = "../librustc_error_codes" } diff --git a/src/librustc_mir/borrow_check/nll/type_check/mod.rs b/src/librustc_mir/borrow_check/nll/type_check/mod.rs index cdfbca65e7e..6e9e8abbeff 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/mod.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/mod.rs @@ -51,6 +51,8 @@ use std::rc::Rc; use std::{fmt, iter, mem}; use syntax_pos::{Span, DUMMY_SP}; +use rustc_error_codes::*; + macro_rules! span_mirbug { ($context:expr, $elem:expr, $($message:tt)*) => ({ $crate::borrow_check::nll::type_check::mirbug( diff --git a/src/librustc_mir/error_codes.rs b/src/librustc_mir/error_codes.rs deleted file mode 100644 index c119ca536fb..00000000000 --- a/src/librustc_mir/error_codes.rs +++ /dev/null @@ -1,2552 +0,0 @@ -syntax::register_diagnostics! { - - -E0001: r##" -#### Note: this error code is no longer emitted by the compiler. - -This error suggests that the expression arm corresponding to the noted pattern -will never be reached as for all possible values of the expression being -matched, one of the preceding patterns will match. - -This means that perhaps some of the preceding patterns are too general, this -one is too specific or the ordering is incorrect. - -For example, the following `match` block has too many arms: - -``` -match Some(0) { - Some(bar) => {/* ... */} - x => {/* ... */} // This handles the `None` case - _ => {/* ... */} // All possible cases have already been handled -} -``` - -`match` blocks have their patterns matched in order, so, for example, putting -a wildcard arm above a more specific arm will make the latter arm irrelevant. - -Ensure the ordering of the match arm is correct and remove any superfluous -arms. -"##, - -E0002: r##" -#### Note: this error code is no longer emitted by the compiler. - -This error indicates that an empty match expression is invalid because the type -it is matching on is non-empty (there exist values of this type). In safe code -it is impossible to create an instance of an empty type, so empty match -expressions are almost never desired. This error is typically fixed by adding -one or more cases to the match expression. - -An example of an empty type is `enum Empty { }`. So, the following will work: - -``` -enum Empty {} - -fn foo(x: Empty) { - match x { - // empty - } -} -``` - -However, this won't: - -```compile_fail -fn foo(x: Option<String>) { - match x { - // empty - } -} -``` -"##, - -E0004: r##" -This error indicates that the compiler cannot guarantee a matching pattern for -one or more possible inputs to a match expression. Guaranteed matches are -required in order to assign values to match expressions, or alternatively, -determine the flow of execution. - -Erroneous code example: - -```compile_fail,E0004 -enum Terminator { - HastaLaVistaBaby, - TalkToMyHand, -} - -let x = Terminator::HastaLaVistaBaby; - -match x { // error: non-exhaustive patterns: `HastaLaVistaBaby` not covered - Terminator::TalkToMyHand => {} -} -``` - -If you encounter this error you must alter your patterns so that every possible -value of the input type is matched. For types with a small number of variants -(like enums) you should probably cover all cases explicitly. Alternatively, the -underscore `_` wildcard pattern can be added after all other patterns to match -"anything else". Example: - -``` -enum Terminator { - HastaLaVistaBaby, - TalkToMyHand, -} - -let x = Terminator::HastaLaVistaBaby; - -match x { - Terminator::TalkToMyHand => {} - Terminator::HastaLaVistaBaby => {} -} - -// or: - -match x { - Terminator::TalkToMyHand => {} - _ => {} -} -``` -"##, - -E0005: r##" -Patterns used to bind names must be irrefutable, that is, they must guarantee -that a name will be extracted in all cases. - -Erroneous code example: - -```compile_fail,E0005 -let x = Some(1); -let Some(y) = x; -// error: refutable pattern in local binding: `None` not covered -``` - -If you encounter this error you probably need to use a `match` or `if let` to -deal with the possibility of failure. Example: - -``` -let x = Some(1); - -match x { - Some(y) => { - // do something - }, - None => {} -} - -// or: - -if let Some(y) = x { - // do something -} -``` -"##, - -E0007: r##" -This error indicates that the bindings in a match arm would require a value to -be moved into more than one location, thus violating unique ownership. Code -like the following is invalid as it requires the entire `Option<String>` to be -moved into a variable called `op_string` while simultaneously requiring the -inner `String` to be moved into a variable called `s`. - -Erroneous code example: - -```compile_fail,E0007 -let x = Some("s".to_string()); - -match x { - op_string @ Some(s) => {}, // error: cannot bind by-move with sub-bindings - None => {}, -} -``` - -See also the error E0303. -"##, - -E0009: r##" -In a pattern, all values that don't implement the `Copy` trait have to be bound -the same way. The goal here is to avoid binding simultaneously by-move and -by-ref. - -This limitation may be removed in a future version of Rust. - -Erroneous code example: - -```compile_fail,E0009 -struct X { x: (), } - -let x = Some((X { x: () }, X { x: () })); -match x { - Some((y, ref z)) => {}, // error: cannot bind by-move and by-ref in the - // same pattern - None => panic!() -} -``` - -You have two solutions: - -Solution #1: Bind the pattern's values the same way. - -``` -struct X { x: (), } - -let x = Some((X { x: () }, X { x: () })); -match x { - Some((ref y, ref z)) => {}, - // or Some((y, z)) => {} - None => panic!() -} -``` - -Solution #2: Implement the `Copy` trait for the `X` structure. - -However, please keep in mind that the first solution should be preferred. - -``` -#[derive(Clone, Copy)] -struct X { x: (), } - -let x = Some((X { x: () }, X { x: () })); -match x { - Some((y, ref z)) => {}, - None => panic!() -} -``` -"##, - -E0010: r##" -The value of statics and constants must be known at compile time, and they live -for the entire lifetime of a program. Creating a boxed value allocates memory on -the heap at runtime, and therefore cannot be done at compile time. - -Erroneous code example: - -```compile_fail,E0010 -#![feature(box_syntax)] - -const CON : Box<i32> = box 0; -``` -"##, - -E0013: r##" -Static and const variables can refer to other const variables. But a const -variable cannot refer to a static variable. - -Erroneous code example: - -```compile_fail,E0013 -static X: i32 = 42; -const Y: i32 = X; -``` - -In this example, `Y` cannot refer to `X` here. To fix this, the value can be -extracted as a const and then used: - -``` -const A: i32 = 42; -static X: i32 = A; -const Y: i32 = A; -``` -"##, - -// FIXME(#57563) Change the language here when const fn stabilizes -E0015: r##" -The only functions that can be called in static or constant expressions are -`const` functions, and struct/enum constructors. `const` functions are only -available on a nightly compiler. Rust currently does not support more general -compile-time function execution. - -``` -const FOO: Option<u8> = Some(1); // enum constructor -struct Bar {x: u8} -const BAR: Bar = Bar {x: 1}; // struct constructor -``` - -See [RFC 911] for more details on the design of `const fn`s. - -[RFC 911]: https://github.com/rust-lang/rfcs/blob/master/text/0911-const-fn.md -"##, - -E0017: r##" -References in statics and constants may only refer to immutable values. - -Erroneous code example: - -```compile_fail,E0017 -static X: i32 = 1; -const C: i32 = 2; - -// these three are not allowed: -const CR: &mut i32 = &mut C; -static STATIC_REF: &'static mut i32 = &mut X; -static CONST_REF: &'static mut i32 = &mut C; -``` - -Statics are shared everywhere, and if they refer to mutable data one might -violate memory safety since holding multiple mutable references to shared data -is not allowed. - -If you really want global mutable state, try using `static mut` or a global -`UnsafeCell`. -"##, - -E0019: r##" -A function call isn't allowed in the const's initialization expression -because the expression's value must be known at compile-time. - -Erroneous code example: - -```compile_fail,E0019 -#![feature(box_syntax)] - -fn main() { - struct MyOwned; - - static STATIC11: Box<MyOwned> = box MyOwned; // error! -} -``` - -Remember: you can't use a function call inside a const's initialization -expression! However, you can totally use it anywhere else: - -``` -enum Test { - V1 -} - -impl Test { - fn func(&self) -> i32 { - 12 - } -} - -fn main() { - const FOO: Test = Test::V1; - - FOO.func(); // here is good - let x = FOO.func(); // or even here! -} -``` -"##, - -E0030: r##" -When matching against a range, the compiler verifies that the range is -non-empty. Range patterns include both end-points, so this is equivalent to -requiring the start of the range to be less than or equal to the end of the -range. - -Erroneous code example: - -```compile_fail,E0030 -match 5u32 { - // This range is ok, albeit pointless. - 1 ..= 1 => {} - // This range is empty, and the compiler can tell. - 1000 ..= 5 => {} -} -``` -"##, - -E0133: r##" -Unsafe code was used outside of an unsafe function or block. - -Erroneous code example: - -```compile_fail,E0133 -unsafe fn f() { return; } // This is the unsafe code - -fn main() { - f(); // error: call to unsafe function requires unsafe function or block -} -``` - -Using unsafe functionality is potentially dangerous and disallowed by safety -checks. Examples: - -* Dereferencing raw pointers -* Calling functions via FFI -* Calling functions marked unsafe - -These safety checks can be relaxed for a section of the code by wrapping the -unsafe instructions with an `unsafe` block. For instance: - -``` -unsafe fn f() { return; } - -fn main() { - unsafe { f(); } // ok! -} -``` - -See also https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html -"##, - -E0158: r##" -An associated const has been referenced in a pattern. - -Erroneous code example: - -```compile_fail,E0158 -enum EFoo { A, B, C, D } - -trait Foo { - const X: EFoo; -} - -fn test<A: Foo>(arg: EFoo) { - match arg { - A::X => { // error! - println!("A::X"); - } - } -} -``` - -`const` and `static` mean different things. A `const` is a compile-time -constant, an alias for a literal value. This property means you can match it -directly within a pattern. - -The `static` keyword, on the other hand, guarantees a fixed location in memory. -This does not always mean that the value is constant. For example, a global -mutex can be declared `static` as well. - -If you want to match against a `static`, consider using a guard instead: - -``` -static FORTY_TWO: i32 = 42; - -match Some(42) { - Some(x) if x == FORTY_TWO => {} - _ => {} -} -``` -"##, - -E0161: r##" -A value was moved. However, its size was not known at compile time, and only -values of a known size can be moved. - -Erroneous code example: - -```compile_fail,E0161 -#![feature(box_syntax)] - -fn main() { - let array: &[isize] = &[1, 2, 3]; - let _x: Box<[isize]> = box *array; - // error: cannot move a value of type [isize]: the size of [isize] cannot - // be statically determined -} -``` - -In Rust, you can only move a value when its size is known at compile time. - -To work around this restriction, consider "hiding" the value behind a reference: -either `&x` or `&mut x`. Since a reference has a fixed size, this lets you move -it around as usual. Example: - -``` -#![feature(box_syntax)] - -fn main() { - let array: &[isize] = &[1, 2, 3]; - let _x: Box<&[isize]> = box array; // ok! -} -``` -"##, - -E0162: r##" -#### Note: this error code is no longer emitted by the compiler. - -An if-let pattern attempts to match the pattern, and enters the body if the -match was successful. If the match is irrefutable (when it cannot fail to -match), use a regular `let`-binding instead. For instance: - -``` -struct Irrefutable(i32); -let irr = Irrefutable(0); - -// This fails to compile because the match is irrefutable. -if let Irrefutable(x) = irr { - // This body will always be executed. - // ... -} -``` - -Try this instead: - -``` -struct Irrefutable(i32); -let irr = Irrefutable(0); - -let Irrefutable(x) = irr; -println!("{}", x); -``` -"##, - -E0165: r##" -#### Note: this error code is no longer emitted by the compiler. - -A while-let pattern attempts to match the pattern, and enters the body if the -match was successful. If the match is irrefutable (when it cannot fail to -match), use a regular `let`-binding inside a `loop` instead. For instance: - -```no_run -struct Irrefutable(i32); -let irr = Irrefutable(0); - -// This fails to compile because the match is irrefutable. -while let Irrefutable(x) = irr { - // ... -} -``` - -Try this instead: - -```no_run -struct Irrefutable(i32); -let irr = Irrefutable(0); - -loop { - let Irrefutable(x) = irr; - // ... -} -``` -"##, - -E0170: r##" -Enum variants are qualified by default. For example, given this type: - -``` -enum Method { - GET, - POST, -} -``` - -You would match it using: - -``` -enum Method { - GET, - POST, -} - -let m = Method::GET; - -match m { - Method::GET => {}, - Method::POST => {}, -} -``` - -If you don't qualify the names, the code will bind new variables named "GET" and -"POST" instead. This behavior is likely not what you want, so `rustc` warns when -that happens. - -Qualified names are good practice, and most code works well with them. But if -you prefer them unqualified, you can import the variants into scope: - -``` -use Method::*; -enum Method { GET, POST } -# fn main() {} -``` - -If you want others to be able to import variants from your module directly, use -`pub use`: - -``` -pub use Method::*; -pub enum Method { GET, POST } -# fn main() {} -``` -"##, - - -E0297: r##" -#### Note: this error code is no longer emitted by the compiler. - -Patterns used to bind names must be irrefutable. That is, they must guarantee -that a name will be extracted in all cases. Instead of pattern matching the -loop variable, consider using a `match` or `if let` inside the loop body. For -instance: - -```compile_fail,E0005 -let xs : Vec<Option<i32>> = vec![Some(1), None]; - -// This fails because `None` is not covered. -for Some(x) in xs { - // ... -} -``` - -Match inside the loop instead: - -``` -let xs : Vec<Option<i32>> = vec![Some(1), None]; - -for item in xs { - match item { - Some(x) => {}, - None => {}, - } -} -``` - -Or use `if let`: - -``` -let xs : Vec<Option<i32>> = vec![Some(1), None]; - -for item in xs { - if let Some(x) = item { - // ... - } -} -``` -"##, - -E0301: r##" -#### Note: this error code is no longer emitted by the compiler. - -Mutable borrows are not allowed in pattern guards, because matching cannot have -side effects. Side effects could alter the matched object or the environment -on which the match depends in such a way, that the match would not be -exhaustive. For instance, the following would not match any arm if mutable -borrows were allowed: - -```compile_fail,E0596 -match Some(()) { - None => { }, - option if option.take().is_none() => { - /* impossible, option is `Some` */ - }, - Some(_) => { } // When the previous match failed, the option became `None`. -} -``` -"##, - -E0302: r##" -#### Note: this error code is no longer emitted by the compiler. - -Assignments are not allowed in pattern guards, because matching cannot have -side effects. Side effects could alter the matched object or the environment -on which the match depends in such a way, that the match would not be -exhaustive. For instance, the following would not match any arm if assignments -were allowed: - -```compile_fail,E0594 -match Some(()) { - None => { }, - option if { option = None; false } => { }, - Some(_) => { } // When the previous match failed, the option became `None`. -} -``` -"##, - -E0303: r##" -In certain cases it is possible for sub-bindings to violate memory safety. -Updates to the borrow checker in a future version of Rust may remove this -restriction, but for now patterns must be rewritten without sub-bindings. - -Before: - -```compile_fail,E0303 -match Some("hi".to_string()) { - ref op_string_ref @ Some(s) => {}, - None => {}, -} -``` - -After: - -``` -match Some("hi".to_string()) { - Some(ref s) => { - let op_string_ref = &Some(s); - // ... - }, - None => {}, -} -``` - -The `op_string_ref` binding has type `&Option<&String>` in both cases. - -See also https://github.com/rust-lang/rust/issues/14587 -"##, - -E0373: r##" -This error occurs when an attempt is made to use data captured by a closure, -when that data may no longer exist. It's most commonly seen when attempting to -return a closure: - -```compile_fail,E0373 -fn foo() -> Box<Fn(u32) -> u32> { - let x = 0u32; - Box::new(|y| x + y) -} -``` - -Notice that `x` is stack-allocated by `foo()`. By default, Rust captures -closed-over data by reference. This means that once `foo()` returns, `x` no -longer exists. An attempt to access `x` within the closure would thus be -unsafe. - -Another situation where this might be encountered is when spawning threads: - -```compile_fail,E0373 -fn foo() { - let x = 0u32; - let y = 1u32; - - let thr = std::thread::spawn(|| { - x + y - }); -} -``` - -Since our new thread runs in parallel, the stack frame containing `x` and `y` -may well have disappeared by the time we try to use them. Even if we call -`thr.join()` within foo (which blocks until `thr` has completed, ensuring the -stack frame won't disappear), we will not succeed: the compiler cannot prove -that this behaviour is safe, and so won't let us do it. - -The solution to this problem is usually to switch to using a `move` closure. -This approach moves (or copies, where possible) data into the closure, rather -than taking references to it. For example: - -``` -fn foo() -> Box<Fn(u32) -> u32> { - let x = 0u32; - Box::new(move |y| x + y) -} -``` - -Now that the closure has its own copy of the data, there's no need to worry -about safety. -"##, - -E0381: r##" -It is not allowed to use or capture an uninitialized variable. - -Erroneous code example: - -```compile_fail,E0381 -fn main() { - let x: i32; - let y = x; // error, use of possibly-uninitialized variable -} -``` - -To fix this, ensure that any declared variables are initialized before being -used. Example: - -``` -fn main() { - let x: i32 = 0; - let y = x; // ok! -} -``` -"##, - -E0382: r##" -This error occurs when an attempt is made to use a variable after its contents -have been moved elsewhere. - -Erroneous code example: - -```compile_fail,E0382 -struct MyStruct { s: u32 } - -fn main() { - let mut x = MyStruct{ s: 5u32 }; - let y = x; - x.s = 6; - println!("{}", x.s); -} -``` - -Since `MyStruct` is a type that is not marked `Copy`, the data gets moved out -of `x` when we set `y`. This is fundamental to Rust's ownership system: outside -of workarounds like `Rc`, a value cannot be owned by more than one variable. - -Sometimes we don't need to move the value. Using a reference, we can let another -function borrow the value without changing its ownership. In the example below, -we don't actually have to move our string to `calculate_length`, we can give it -a reference to it with `&` instead. - -``` -fn main() { - let s1 = String::from("hello"); - - let len = calculate_length(&s1); - - println!("The length of '{}' is {}.", s1, len); -} - -fn calculate_length(s: &String) -> usize { - s.len() -} -``` - -A mutable reference can be created with `&mut`. - -Sometimes we don't want a reference, but a duplicate. All types marked `Clone` -can be duplicated by calling `.clone()`. Subsequent changes to a clone do not -affect the original variable. - -Most types in the standard library are marked `Clone`. The example below -demonstrates using `clone()` on a string. `s1` is first set to "many", and then -copied to `s2`. Then the first character of `s1` is removed, without affecting -`s2`. "any many" is printed to the console. - -``` -fn main() { - let mut s1 = String::from("many"); - let s2 = s1.clone(); - s1.remove(0); - println!("{} {}", s1, s2); -} -``` - -If we control the definition of a type, we can implement `Clone` on it ourselves -with `#[derive(Clone)]`. - -Some types have no ownership semantics at all and are trivial to duplicate. An -example is `i32` and the other number types. We don't have to call `.clone()` to -clone them, because they are marked `Copy` in addition to `Clone`. Implicit -cloning is more convenient in this case. We can mark our own types `Copy` if -all their members also are marked `Copy`. - -In the example below, we implement a `Point` type. Because it only stores two -integers, we opt-out of ownership semantics with `Copy`. Then we can -`let p2 = p1` without `p1` being moved. - -``` -#[derive(Copy, Clone)] -struct Point { x: i32, y: i32 } - -fn main() { - let mut p1 = Point{ x: -1, y: 2 }; - let p2 = p1; - p1.x = 1; - println!("p1: {}, {}", p1.x, p1.y); - println!("p2: {}, {}", p2.x, p2.y); -} -``` - -Alternatively, if we don't control the struct's definition, or mutable shared -ownership is truly required, we can use `Rc` and `RefCell`: - -``` -use std::cell::RefCell; -use std::rc::Rc; - -struct MyStruct { s: u32 } - -fn main() { - let mut x = Rc::new(RefCell::new(MyStruct{ s: 5u32 })); - let y = x.clone(); - x.borrow_mut().s = 6; - println!("{}", x.borrow().s); -} -``` - -With this approach, x and y share ownership of the data via the `Rc` (reference -count type). `RefCell` essentially performs runtime borrow checking: ensuring -that at most one writer or multiple readers can access the data at any one time. - -If you wish to learn more about ownership in Rust, start with the chapter in the -Book: - -https://doc.rust-lang.org/book/ch04-00-understanding-ownership.html -"##, - -E0383: r##" -#### Note: this error code is no longer emitted by the compiler. - -This error occurs when an attempt is made to partially reinitialize a -structure that is currently uninitialized. - -For example, this can happen when a drop has taken place: - -```compile_fail -struct Foo { - a: u32, -} -impl Drop for Foo { - fn drop(&mut self) { /* ... */ } -} - -let mut x = Foo { a: 1 }; -drop(x); // `x` is now uninitialized -x.a = 2; // error, partial reinitialization of uninitialized structure `t` -``` - -This error can be fixed by fully reinitializing the structure in question: - -``` -struct Foo { - a: u32, -} -impl Drop for Foo { - fn drop(&mut self) { /* ... */ } -} - -let mut x = Foo { a: 1 }; -drop(x); -x = Foo { a: 2 }; -``` -"##, - -E0384: r##" -This error occurs when an attempt is made to reassign an immutable variable. - -Erroneous code example: - -```compile_fail,E0384 -fn main() { - let x = 3; - x = 5; // error, reassignment of immutable variable -} -``` - -By default, variables in Rust are immutable. To fix this error, add the keyword -`mut` after the keyword `let` when declaring the variable. For example: - -``` -fn main() { - let mut x = 3; - x = 5; -} -``` -"##, - -E0386: r##" -#### Note: this error code is no longer emitted by the compiler. - -This error occurs when an attempt is made to mutate the target of a mutable -reference stored inside an immutable container. - -For example, this can happen when storing a `&mut` inside an immutable `Box`: - -``` -let mut x: i64 = 1; -let y: Box<_> = Box::new(&mut x); -**y = 2; // error, cannot assign to data in an immutable container -``` - -This error can be fixed by making the container mutable: - -``` -let mut x: i64 = 1; -let mut y: Box<_> = Box::new(&mut x); -**y = 2; -``` - -It can also be fixed by using a type with interior mutability, such as `Cell` -or `RefCell`: - -``` -use std::cell::Cell; - -let x: i64 = 1; -let y: Box<Cell<_>> = Box::new(Cell::new(x)); -y.set(2); -``` -"##, - -E0387: r##" -#### Note: this error code is no longer emitted by the compiler. - -This error occurs when an attempt is made to mutate or mutably reference data -that a closure has captured immutably. - -Erroneous code example: - -```compile_fail -// Accepts a function or a closure that captures its environment immutably. -// Closures passed to foo will not be able to mutate their closed-over state. -fn foo<F: Fn()>(f: F) { } - -// Attempts to mutate closed-over data. Error message reads: -// `cannot assign to data in a captured outer variable...` -fn mutable() { - let mut x = 0u32; - foo(|| x = 2); -} - -// Attempts to take a mutable reference to closed-over data. Error message -// reads: `cannot borrow data mutably in a captured outer variable...` -fn mut_addr() { - let mut x = 0u32; - foo(|| { let y = &mut x; }); -} -``` - -The problem here is that foo is defined as accepting a parameter of type `Fn`. -Closures passed into foo will thus be inferred to be of type `Fn`, meaning that -they capture their context immutably. - -If the definition of `foo` is under your control, the simplest solution is to -capture the data mutably. This can be done by defining `foo` to take FnMut -rather than Fn: - -``` -fn foo<F: FnMut()>(f: F) { } -``` - -Alternatively, we can consider using the `Cell` and `RefCell` types to achieve -interior mutability through a shared reference. Our example's `mutable` -function could be redefined as below: - -``` -use std::cell::Cell; - -fn foo<F: Fn()>(f: F) { } - -fn mutable() { - let x = Cell::new(0u32); - foo(|| x.set(2)); -} -``` - -You can read more about cell types in the API documentation: - -https://doc.rust-lang.org/std/cell/ -"##, - -E0388: r##" -#### Note: this error code is no longer emitted by the compiler. -"##, - -E0389: r##" -#### Note: this error code is no longer emitted by the compiler. - -An attempt was made to mutate data using a non-mutable reference. This -commonly occurs when attempting to assign to a non-mutable reference of a -mutable reference (`&(&mut T)`). - -Erroneous code example: - -```compile_fail -struct FancyNum { - num: u8, -} - -fn main() { - let mut fancy = FancyNum{ num: 5 }; - let fancy_ref = &(&mut fancy); - fancy_ref.num = 6; // error: cannot assign to data in a `&` reference - println!("{}", fancy_ref.num); -} -``` - -Here, `&mut fancy` is mutable, but `&(&mut fancy)` is not. Creating an -immutable reference to a value borrows it immutably. There can be multiple -references of type `&(&mut T)` that point to the same value, so they must be -immutable to prevent multiple mutable references to the same value. - -To fix this, either remove the outer reference: - -``` -struct FancyNum { - num: u8, -} - -fn main() { - let mut fancy = FancyNum{ num: 5 }; - - let fancy_ref = &mut fancy; - // `fancy_ref` is now &mut FancyNum, rather than &(&mut FancyNum) - - fancy_ref.num = 6; // No error! - - println!("{}", fancy_ref.num); -} -``` - -Or make the outer reference mutable: - -``` -struct FancyNum { - num: u8 -} - -fn main() { - let mut fancy = FancyNum{ num: 5 }; - - let fancy_ref = &mut (&mut fancy); - // `fancy_ref` is now &mut(&mut FancyNum), rather than &(&mut FancyNum) - - fancy_ref.num = 6; // No error! - - println!("{}", fancy_ref.num); -} -``` -"##, - -E0492: r##" -A borrow of a constant containing interior mutability was attempted. - -Erroneous code example: - -```compile_fail,E0492 -use std::sync::atomic::AtomicUsize; - -const A: AtomicUsize = AtomicUsize::new(0); -static B: &'static AtomicUsize = &A; -// error: cannot borrow a constant which may contain interior mutability, -// create a static instead -``` - -A `const` represents a constant value that should never change. If one takes -a `&` reference to the constant, then one is taking a pointer to some memory -location containing the value. Normally this is perfectly fine: most values -can't be changed via a shared `&` pointer, but interior mutability would allow -it. That is, a constant value could be mutated. On the other hand, a `static` is -explicitly a single memory location, which can be mutated at will. - -So, in order to solve this error, either use statics which are `Sync`: - -``` -use std::sync::atomic::AtomicUsize; - -static A: AtomicUsize = AtomicUsize::new(0); -static B: &'static AtomicUsize = &A; // ok! -``` - -You can also have this error while using a cell type: - -```compile_fail,E0492 -use std::cell::Cell; - -const A: Cell<usize> = Cell::new(1); -const B: &Cell<usize> = &A; -// error: cannot borrow a constant which may contain interior mutability, -// create a static instead - -// or: -struct C { a: Cell<usize> } - -const D: C = C { a: Cell::new(1) }; -const E: &Cell<usize> = &D.a; // error - -// or: -const F: &C = &D; // error -``` - -This is because cell types do operations that are not thread-safe. Due to this, -they don't implement Sync and thus can't be placed in statics. - -However, if you still wish to use these types, you can achieve this by an unsafe -wrapper: - -``` -use std::cell::Cell; -use std::marker::Sync; - -struct NotThreadSafe<T> { - value: Cell<T>, -} - -unsafe impl<T> Sync for NotThreadSafe<T> {} - -static A: NotThreadSafe<usize> = NotThreadSafe { value : Cell::new(1) }; -static B: &'static NotThreadSafe<usize> = &A; // ok! -``` - -Remember this solution is unsafe! You will have to ensure that accesses to the -cell are synchronized. -"##, - -E0493: r##" -A type with a `Drop` implementation was destructured when trying to initialize -a static item. - -Erroneous code example: - -```compile_fail,E0493 -enum DropType { - A, -} - -impl Drop for DropType { - fn drop(&mut self) {} -} - -struct Foo { - field1: DropType, -} - -static FOO: Foo = Foo { ..Foo { field1: DropType::A } }; // error! -``` - -The problem here is that if the given type or one of its fields implements the -`Drop` trait, this `Drop` implementation cannot be called during the static -type initialization which might cause a memory leak. To prevent this issue, -you need to instantiate all the static type's fields by hand. - -``` -enum DropType { - A, -} - -impl Drop for DropType { - fn drop(&mut self) {} -} - -struct Foo { - field1: DropType, -} - -static FOO: Foo = Foo { field1: DropType::A }; // We initialize all fields - // by hand. -``` -"##, - -E0499: r##" -A variable was borrowed as mutable more than once. - -Erroneous code example: - -```compile_fail,E0499 -let mut i = 0; -let mut x = &mut i; -let mut a = &mut i; -x; -// error: cannot borrow `i` as mutable more than once at a time -``` - -Please note that in rust, you can either have many immutable references, or one -mutable reference. Take a look at -https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html for more -information. Example: - - -``` -let mut i = 0; -let mut x = &mut i; // ok! - -// or: -let mut i = 0; -let a = &i; // ok! -let b = &i; // still ok! -let c = &i; // still ok! -b; -a; -``` -"##, - -E0500: r##" -A borrowed variable was used by a closure. - -Erroneous code example: - -```compile_fail,E0500 -fn you_know_nothing(jon_snow: &mut i32) { - let nights_watch = &jon_snow; - let starks = || { - *jon_snow = 3; // error: closure requires unique access to `jon_snow` - // but it is already borrowed - }; - println!("{}", nights_watch); -} -``` - -In here, `jon_snow` is already borrowed by the `nights_watch` reference, so it -cannot be borrowed by the `starks` closure at the same time. To fix this issue, -you can create the closure after the borrow has ended: - -``` -fn you_know_nothing(jon_snow: &mut i32) { - let nights_watch = &jon_snow; - println!("{}", nights_watch); - let starks = || { - *jon_snow = 3; - }; -} -``` - -Or, if the type implements the `Clone` trait, you can clone it between -closures: - -``` -fn you_know_nothing(jon_snow: &mut i32) { - let mut jon_copy = jon_snow.clone(); - let starks = || { - *jon_snow = 3; - }; - println!("{}", jon_copy); -} -``` -"##, - -E0501: r##" -This error indicates that a mutable variable is being used while it is still -captured by a closure. Because the closure has borrowed the variable, it is not -available for use until the closure goes out of scope. - -Note that a capture will either move or borrow a variable, but in this -situation, the closure is borrowing the variable. Take a look at -http://rustbyexample.com/fn/closures/capture.html for more information about -capturing. - -Erroneous code example: - -```compile_fail,E0501 -fn inside_closure(x: &mut i32) { - // Actions which require unique access -} - -fn outside_closure(x: &mut i32) { - // Actions which require unique access -} - -fn foo(a: &mut i32) { - let mut bar = || { - inside_closure(a) - }; - outside_closure(a); // error: cannot borrow `*a` as mutable because previous - // closure requires unique access. - bar(); -} -``` - -To fix this error, you can finish using the closure before using the captured -variable: - -``` -fn inside_closure(x: &mut i32) {} -fn outside_closure(x: &mut i32) {} - -fn foo(a: &mut i32) { - let mut bar = || { - inside_closure(a) - }; - bar(); - // borrow on `a` ends. - outside_closure(a); // ok! -} -``` - -Or you can pass the variable as a parameter to the closure: - -``` -fn inside_closure(x: &mut i32) {} -fn outside_closure(x: &mut i32) {} - -fn foo(a: &mut i32) { - let mut bar = |s: &mut i32| { - inside_closure(s) - }; - outside_closure(a); - bar(a); -} -``` - -It may be possible to define the closure later: - -``` -fn inside_closure(x: &mut i32) {} -fn outside_closure(x: &mut i32) {} - -fn foo(a: &mut i32) { - outside_closure(a); - let mut bar = || { - inside_closure(a) - }; - bar(); -} -``` -"##, - -E0502: r##" -This error indicates that you are trying to borrow a variable as mutable when it -has already been borrowed as immutable. - -Erroneous code example: - -```compile_fail,E0502 -fn bar(x: &mut i32) {} -fn foo(a: &mut i32) { - let ref y = a; // a is borrowed as immutable. - bar(a); // error: cannot borrow `*a` as mutable because `a` is also borrowed - // as immutable - println!("{}", y); -} -``` - -To fix this error, ensure that you don't have any other references to the -variable before trying to access it mutably: - -``` -fn bar(x: &mut i32) {} -fn foo(a: &mut i32) { - bar(a); - let ref y = a; // ok! - println!("{}", y); -} -``` - -For more information on the rust ownership system, take a look at -https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html. -"##, - -E0503: r##" -A value was used after it was mutably borrowed. - -Erroneous code example: - -```compile_fail,E0503 -fn main() { - let mut value = 3; - // Create a mutable borrow of `value`. - let borrow = &mut value; - let _sum = value + 1; // error: cannot use `value` because - // it was mutably borrowed - println!("{}", borrow); -} -``` - -In this example, `value` is mutably borrowed by `borrow` and cannot be -used to calculate `sum`. This is not possible because this would violate -Rust's mutability rules. - -You can fix this error by finishing using the borrow before the next use of -the value: - -``` -fn main() { - let mut value = 3; - let borrow = &mut value; - println!("{}", borrow); - // The block has ended and with it the borrow. - // You can now use `value` again. - let _sum = value + 1; -} -``` - -Or by cloning `value` before borrowing it: - -``` -fn main() { - let mut value = 3; - // We clone `value`, creating a copy. - let value_cloned = value.clone(); - // The mutable borrow is a reference to `value` and - // not to `value_cloned`... - let borrow = &mut value; - // ... which means we can still use `value_cloned`, - let _sum = value_cloned + 1; - // even though the borrow only ends here. - println!("{}", borrow); -} -``` - -You can find more information about borrowing in the rust-book: -http://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html -"##, - -E0504: r##" -#### Note: this error code is no longer emitted by the compiler. - -This error occurs when an attempt is made to move a borrowed variable into a -closure. - -Erroneous code example: - -```compile_fail -struct FancyNum { - num: u8, -} - -fn main() { - let fancy_num = FancyNum { num: 5 }; - let fancy_ref = &fancy_num; - - let x = move || { - println!("child function: {}", fancy_num.num); - // error: cannot move `fancy_num` into closure because it is borrowed - }; - - x(); - println!("main function: {}", fancy_ref.num); -} -``` - -Here, `fancy_num` is borrowed by `fancy_ref` and so cannot be moved into -the closure `x`. There is no way to move a value into a closure while it is -borrowed, as that would invalidate the borrow. - -If the closure can't outlive the value being moved, try using a reference -rather than moving: - -``` -struct FancyNum { - num: u8, -} - -fn main() { - let fancy_num = FancyNum { num: 5 }; - let fancy_ref = &fancy_num; - - let x = move || { - // fancy_ref is usable here because it doesn't move `fancy_num` - println!("child function: {}", fancy_ref.num); - }; - - x(); - - println!("main function: {}", fancy_num.num); -} -``` - -If the value has to be borrowed and then moved, try limiting the lifetime of -the borrow using a scoped block: - -``` -struct FancyNum { - num: u8, -} - -fn main() { - let fancy_num = FancyNum { num: 5 }; - - { - let fancy_ref = &fancy_num; - println!("main function: {}", fancy_ref.num); - // `fancy_ref` goes out of scope here - } - - let x = move || { - // `fancy_num` can be moved now (no more references exist) - println!("child function: {}", fancy_num.num); - }; - - x(); -} -``` - -If the lifetime of a reference isn't enough, such as in the case of threading, -consider using an `Arc` to create a reference-counted value: - -``` -use std::sync::Arc; -use std::thread; - -struct FancyNum { - num: u8, -} - -fn main() { - let fancy_ref1 = Arc::new(FancyNum { num: 5 }); - let fancy_ref2 = fancy_ref1.clone(); - - let x = thread::spawn(move || { - // `fancy_ref1` can be moved and has a `'static` lifetime - println!("child thread: {}", fancy_ref1.num); - }); - - x.join().expect("child thread should finish"); - println!("main thread: {}", fancy_ref2.num); -} -``` -"##, - -E0505: r##" -A value was moved out while it was still borrowed. - -Erroneous code example: - -```compile_fail,E0505 -struct Value {} - -fn borrow(val: &Value) {} - -fn eat(val: Value) {} - -fn main() { - let x = Value{}; - let _ref_to_val: &Value = &x; - eat(x); - borrow(_ref_to_val); -} -``` - -Here, the function `eat` takes ownership of `x`. However, -`x` cannot be moved because the borrow to `_ref_to_val` -needs to last till the function `borrow`. -To fix that you can do a few different things: - -* Try to avoid moving the variable. -* Release borrow before move. -* Implement the `Copy` trait on the type. - -Examples: - -``` -struct Value {} - -fn borrow(val: &Value) {} - -fn eat(val: &Value) {} - -fn main() { - let x = Value{}; - - let ref_to_val: &Value = &x; - eat(&x); // pass by reference, if it's possible - borrow(ref_to_val); -} -``` - -Or: - -``` -struct Value {} - -fn borrow(val: &Value) {} - -fn eat(val: Value) {} - -fn main() { - let x = Value{}; - - let ref_to_val: &Value = &x; - borrow(ref_to_val); - // ref_to_val is no longer used. - eat(x); -} -``` - -Or: - -``` -#[derive(Clone, Copy)] // implement Copy trait -struct Value {} - -fn borrow(val: &Value) {} - -fn eat(val: Value) {} - -fn main() { - let x = Value{}; - let ref_to_val: &Value = &x; - eat(x); // it will be copied here. - borrow(ref_to_val); -} -``` - -You can find more information about borrowing in the rust-book: -http://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html -"##, - -E0506: r##" -This error occurs when an attempt is made to assign to a borrowed value. - -Erroneous code example: - -```compile_fail,E0506 -struct FancyNum { - num: u8, -} - -fn main() { - let mut fancy_num = FancyNum { num: 5 }; - let fancy_ref = &fancy_num; - fancy_num = FancyNum { num: 6 }; - // error: cannot assign to `fancy_num` because it is borrowed - - println!("Num: {}, Ref: {}", fancy_num.num, fancy_ref.num); -} -``` - -Because `fancy_ref` still holds a reference to `fancy_num`, `fancy_num` can't -be assigned to a new value as it would invalidate the reference. - -Alternatively, we can move out of `fancy_num` into a second `fancy_num`: - -``` -struct FancyNum { - num: u8, -} - -fn main() { - let mut fancy_num = FancyNum { num: 5 }; - let moved_num = fancy_num; - fancy_num = FancyNum { num: 6 }; - - println!("Num: {}, Moved num: {}", fancy_num.num, moved_num.num); -} -``` - -If the value has to be borrowed, try limiting the lifetime of the borrow using -a scoped block: - -``` -struct FancyNum { - num: u8, -} - -fn main() { - let mut fancy_num = FancyNum { num: 5 }; - - { - let fancy_ref = &fancy_num; - println!("Ref: {}", fancy_ref.num); - } - - // Works because `fancy_ref` is no longer in scope - fancy_num = FancyNum { num: 6 }; - println!("Num: {}", fancy_num.num); -} -``` - -Or by moving the reference into a function: - -``` -struct FancyNum { - num: u8, -} - -fn main() { - let mut fancy_num = FancyNum { num: 5 }; - - print_fancy_ref(&fancy_num); - - // Works because function borrow has ended - fancy_num = FancyNum { num: 6 }; - println!("Num: {}", fancy_num.num); -} - -fn print_fancy_ref(fancy_ref: &FancyNum){ - println!("Ref: {}", fancy_ref.num); -} -``` -"##, - -E0507: r##" -You tried to move out of a value which was borrowed. - -This can also happen when using a type implementing `Fn` or `FnMut`, as neither -allows moving out of them (they usually represent closures which can be called -more than once). Much of the text following applies equally well to non-`FnOnce` -closure bodies. - -Erroneous code example: - -```compile_fail,E0507 -use std::cell::RefCell; - -struct TheDarkKnight; - -impl TheDarkKnight { - fn nothing_is_true(self) {} -} - -fn main() { - let x = RefCell::new(TheDarkKnight); - - x.borrow().nothing_is_true(); // error: cannot move out of borrowed content -} -``` - -Here, the `nothing_is_true` method takes the ownership of `self`. However, -`self` cannot be moved because `.borrow()` only provides an `&TheDarkKnight`, -which is a borrow of the content owned by the `RefCell`. To fix this error, -you have three choices: - -* Try to avoid moving the variable. -* Somehow reclaim the ownership. -* Implement the `Copy` trait on the type. - -Examples: - -``` -use std::cell::RefCell; - -struct TheDarkKnight; - -impl TheDarkKnight { - fn nothing_is_true(&self) {} // First case, we don't take ownership -} - -fn main() { - let x = RefCell::new(TheDarkKnight); - - x.borrow().nothing_is_true(); // ok! -} -``` - -Or: - -``` -use std::cell::RefCell; - -struct TheDarkKnight; - -impl TheDarkKnight { - fn nothing_is_true(self) {} -} - -fn main() { - let x = RefCell::new(TheDarkKnight); - let x = x.into_inner(); // we get back ownership - - x.nothing_is_true(); // ok! -} -``` - -Or: - -``` -use std::cell::RefCell; - -#[derive(Clone, Copy)] // we implement the Copy trait -struct TheDarkKnight; - -impl TheDarkKnight { - fn nothing_is_true(self) {} -} - -fn main() { - let x = RefCell::new(TheDarkKnight); - - x.borrow().nothing_is_true(); // ok! -} -``` - -Moving a member out of a mutably borrowed struct will also cause E0507 error: - -```compile_fail,E0507 -struct TheDarkKnight; - -impl TheDarkKnight { - fn nothing_is_true(self) {} -} - -struct Batcave { - knight: TheDarkKnight -} - -fn main() { - let mut cave = Batcave { - knight: TheDarkKnight - }; - let borrowed = &mut cave; - - borrowed.knight.nothing_is_true(); // E0507 -} -``` - -It is fine only if you put something back. `mem::replace` can be used for that: - -``` -# struct TheDarkKnight; -# impl TheDarkKnight { fn nothing_is_true(self) {} } -# struct Batcave { knight: TheDarkKnight } -use std::mem; - -let mut cave = Batcave { - knight: TheDarkKnight -}; -let borrowed = &mut cave; - -mem::replace(&mut borrowed.knight, TheDarkKnight).nothing_is_true(); // ok! -``` - -You can find more information about borrowing in the rust-book: -http://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html -"##, - -E0508: r##" -A value was moved out of a non-copy fixed-size array. - -Erroneous code example: - -```compile_fail,E0508 -struct NonCopy; - -fn main() { - let array = [NonCopy; 1]; - let _value = array[0]; // error: cannot move out of type `[NonCopy; 1]`, - // a non-copy fixed-size array -} -``` - -The first element was moved out of the array, but this is not -possible because `NonCopy` does not implement the `Copy` trait. - -Consider borrowing the element instead of moving it: - -``` -struct NonCopy; - -fn main() { - let array = [NonCopy; 1]; - let _value = &array[0]; // Borrowing is allowed, unlike moving. -} -``` - -Alternatively, if your type implements `Clone` and you need to own the value, -consider borrowing and then cloning: - -``` -#[derive(Clone)] -struct NonCopy; - -fn main() { - let array = [NonCopy; 1]; - // Now you can clone the array element. - let _value = array[0].clone(); -} -``` -"##, - -E0509: r##" -This error occurs when an attempt is made to move out of a value whose type -implements the `Drop` trait. - -Erroneous code example: - -```compile_fail,E0509 -struct FancyNum { - num: usize -} - -struct DropStruct { - fancy: FancyNum -} - -impl Drop for DropStruct { - fn drop(&mut self) { - // Destruct DropStruct, possibly using FancyNum - } -} - -fn main() { - let drop_struct = DropStruct{fancy: FancyNum{num: 5}}; - let fancy_field = drop_struct.fancy; // Error E0509 - println!("Fancy: {}", fancy_field.num); - // implicit call to `drop_struct.drop()` as drop_struct goes out of scope -} -``` - -Here, we tried to move a field out of a struct of type `DropStruct` which -implements the `Drop` trait. However, a struct cannot be dropped if one or -more of its fields have been moved. - -Structs implementing the `Drop` trait have an implicit destructor that gets -called when they go out of scope. This destructor may use the fields of the -struct, so moving out of the struct could make it impossible to run the -destructor. Therefore, we must think of all values whose type implements the -`Drop` trait as single units whose fields cannot be moved. - -This error can be fixed by creating a reference to the fields of a struct, -enum, or tuple using the `ref` keyword: - -``` -struct FancyNum { - num: usize -} - -struct DropStruct { - fancy: FancyNum -} - -impl Drop for DropStruct { - fn drop(&mut self) { - // Destruct DropStruct, possibly using FancyNum - } -} - -fn main() { - let drop_struct = DropStruct{fancy: FancyNum{num: 5}}; - let ref fancy_field = drop_struct.fancy; // No more errors! - println!("Fancy: {}", fancy_field.num); - // implicit call to `drop_struct.drop()` as drop_struct goes out of scope -} -``` - -Note that this technique can also be used in the arms of a match expression: - -``` -struct FancyNum { - num: usize -} - -enum DropEnum { - Fancy(FancyNum) -} - -impl Drop for DropEnum { - fn drop(&mut self) { - // Destruct DropEnum, possibly using FancyNum - } -} - -fn main() { - // Creates and enum of type `DropEnum`, which implements `Drop` - let drop_enum = DropEnum::Fancy(FancyNum{num: 10}); - match drop_enum { - // Creates a reference to the inside of `DropEnum::Fancy` - DropEnum::Fancy(ref fancy_field) => // No error! - println!("It was fancy-- {}!", fancy_field.num), - } - // implicit call to `drop_enum.drop()` as drop_enum goes out of scope -} -``` -"##, - -E0510: r##" -Cannot mutate place in this match guard. - -When matching on a variable it cannot be mutated in the match guards, as this -could cause the match to be non-exhaustive: - -```compile_fail,E0510 -let mut x = Some(0); -match x { - None => (), - Some(_) if { x = None; false } => (), - Some(v) => (), // No longer matches -} -``` - -Here executing `x = None` would modify the value being matched and require us -to go "back in time" to the `None` arm. -"##, - -E0515: r##" -Cannot return value that references local variable - -Local variables, function parameters and temporaries are all dropped before the -end of the function body. So a reference to them cannot be returned. - -Erroneous code example: - -```compile_fail,E0515 -fn get_dangling_reference() -> &'static i32 { - let x = 0; - &x -} -``` - -```compile_fail,E0515 -use std::slice::Iter; -fn get_dangling_iterator<'a>() -> Iter<'a, i32> { - let v = vec![1, 2, 3]; - v.iter() -} -``` - -Consider returning an owned value instead: - -``` -use std::vec::IntoIter; - -fn get_integer() -> i32 { - let x = 0; - x -} - -fn get_owned_iterator() -> IntoIter<i32> { - let v = vec![1, 2, 3]; - v.into_iter() -} -``` -"##, - -E0524: r##" -A variable which requires unique access is being used in more than one closure -at the same time. - -Erroneous code example: - -```compile_fail,E0524 -fn set(x: &mut isize) { - *x += 4; -} - -fn dragoooon(x: &mut isize) { - let mut c1 = || set(x); - let mut c2 = || set(x); // error! - - c2(); - c1(); -} -``` - -To solve this issue, multiple solutions are available. First, is it required -for this variable to be used in more than one closure at a time? If it is the -case, use reference counted types such as `Rc` (or `Arc` if it runs -concurrently): - -``` -use std::rc::Rc; -use std::cell::RefCell; - -fn set(x: &mut isize) { - *x += 4; -} - -fn dragoooon(x: &mut isize) { - let x = Rc::new(RefCell::new(x)); - let y = Rc::clone(&x); - let mut c1 = || { let mut x2 = x.borrow_mut(); set(&mut x2); }; - let mut c2 = || { let mut x2 = y.borrow_mut(); set(&mut x2); }; // ok! - - c2(); - c1(); -} -``` - -If not, just run closures one at a time: - -``` -fn set(x: &mut isize) { - *x += 4; -} - -fn dragoooon(x: &mut isize) { - { // This block isn't necessary since non-lexical lifetimes, it's just to - // make it more clear. - let mut c1 = || set(&mut *x); - c1(); - } // `c1` has been dropped here so we're free to use `x` again! - let mut c2 = || set(&mut *x); - c2(); -} -``` -"##, - -E0579: r##" -When matching against an exclusive range, the compiler verifies that the range -is non-empty. Exclusive range patterns include the start point but not the end -point, so this is equivalent to requiring the start of the range to be less -than the end of the range. - -Erroneous code example: - -```compile_fail,E0579 -#![feature(exclusive_range_pattern)] - -fn main() { - match 5u32 { - // This range is ok, albeit pointless. - 1 .. 2 => {} - // This range is empty, and the compiler can tell. - 5 .. 5 => {} // error! - } -} -``` -"##, - -E0595: r##" -#### Note: this error code is no longer emitted by the compiler. - -Closures cannot mutate immutable captured variables. - -Erroneous code example: - -```compile_fail,E0594 -let x = 3; // error: closure cannot assign to immutable local variable `x` -let mut c = || { x += 1 }; -``` - -Make the variable binding mutable: - -``` -let mut x = 3; // ok! -let mut c = || { x += 1 }; -``` -"##, - -E0596: r##" -This error occurs because you tried to mutably borrow a non-mutable variable. - -Erroneous code example: - -```compile_fail,E0596 -let x = 1; -let y = &mut x; // error: cannot borrow mutably -``` - -In here, `x` isn't mutable, so when we try to mutably borrow it in `y`, it -fails. To fix this error, you need to make `x` mutable: - -``` -let mut x = 1; -let y = &mut x; // ok! -``` -"##, - -E0597: r##" -This error occurs because a value was dropped while it was still borrowed - -Erroneous code example: - -```compile_fail,E0597 -struct Foo<'a> { - x: Option<&'a u32>, -} - -let mut x = Foo { x: None }; -{ - let y = 0; - x.x = Some(&y); // error: `y` does not live long enough -} -println!("{:?}", x.x); -``` - -In here, `y` is dropped at the end of the inner scope, but it is borrowed by -`x` until the `println`. To fix the previous example, just remove the scope -so that `y` isn't dropped until after the println - -``` -struct Foo<'a> { - x: Option<&'a u32>, -} - -let mut x = Foo { x: None }; - -let y = 0; -x.x = Some(&y); - -println!("{:?}", x.x); -``` -"##, - -E0626: r##" -This error occurs because a borrow in a generator persists across a -yield point. - -Erroneous code example: - -```compile_fail,E0626 -# #![feature(generators, generator_trait, pin)] -# use std::ops::Generator; -# use std::pin::Pin; -let mut b = || { - let a = &String::new(); // <-- This borrow... - yield (); // ...is still in scope here, when the yield occurs. - println!("{}", a); -}; -Pin::new(&mut b).resume(); -``` - -At present, it is not permitted to have a yield that occurs while a -borrow is still in scope. To resolve this error, the borrow must -either be "contained" to a smaller scope that does not overlap the -yield or else eliminated in another way. So, for example, we might -resolve the previous example by removing the borrow and just storing -the integer by value: - -``` -# #![feature(generators, generator_trait, pin)] -# use std::ops::Generator; -# use std::pin::Pin; -let mut b = || { - let a = 3; - yield (); - println!("{}", a); -}; -Pin::new(&mut b).resume(); -``` - -This is a very simple case, of course. In more complex cases, we may -wish to have more than one reference to the value that was borrowed -- -in those cases, something like the `Rc` or `Arc` types may be useful. - -This error also frequently arises with iteration: - -```compile_fail,E0626 -# #![feature(generators, generator_trait, pin)] -# use std::ops::Generator; -# use std::pin::Pin; -let mut b = || { - let v = vec![1,2,3]; - for &x in &v { // <-- borrow of `v` is still in scope... - yield x; // ...when this yield occurs. - } -}; -Pin::new(&mut b).resume(); -``` - -Such cases can sometimes be resolved by iterating "by value" (or using -`into_iter()`) to avoid borrowing: - -``` -# #![feature(generators, generator_trait, pin)] -# use std::ops::Generator; -# use std::pin::Pin; -let mut b = || { - let v = vec![1,2,3]; - for x in v { // <-- Take ownership of the values instead! - yield x; // <-- Now yield is OK. - } -}; -Pin::new(&mut b).resume(); -``` - -If taking ownership is not an option, using indices can work too: - -``` -# #![feature(generators, generator_trait, pin)] -# use std::ops::Generator; -# use std::pin::Pin; -let mut b = || { - let v = vec![1,2,3]; - let len = v.len(); // (*) - for i in 0..len { - let x = v[i]; // (*) - yield x; // <-- Now yield is OK. - } -}; -Pin::new(&mut b).resume(); - -// (*) -- Unfortunately, these temporaries are currently required. -// See <https://github.com/rust-lang/rust/issues/43122>. -``` -"##, - -E0712: r##" -This error occurs because a borrow of a thread-local variable was made inside a -function which outlived the lifetime of the function. - -Erroneous code example: - -```compile_fail,E0712 -#![feature(thread_local)] - -#[thread_local] -static FOO: u8 = 3; - -fn main() { - let a = &FOO; // error: thread-local variable borrowed past end of function - - std::thread::spawn(move || { - println!("{}", a); - }); -} -``` -"##, - -E0713: r##" -This error occurs when an attempt is made to borrow state past the end of the -lifetime of a type that implements the `Drop` trait. - -Erroneous code example: - -```compile_fail,E0713 -#![feature(nll)] - -pub struct S<'a> { data: &'a mut String } - -impl<'a> Drop for S<'a> { - fn drop(&mut self) { self.data.push_str("being dropped"); } -} - -fn demo<'a>(s: S<'a>) -> &'a mut String { let p = &mut *s.data; p } -``` - -Here, `demo` tries to borrow the string data held within its -argument `s` and then return that borrow. However, `S` is -declared as implementing `Drop`. - -Structs implementing the `Drop` trait have an implicit destructor that -gets called when they go out of scope. This destructor gets exclusive -access to the fields of the struct when it runs. - -This means that when `s` reaches the end of `demo`, its destructor -gets exclusive access to its `&mut`-borrowed string data. allowing -another borrow of that string data (`p`), to exist across the drop of -`s` would be a violation of the principle that `&mut`-borrows have -exclusive, unaliased access to their referenced data. - -This error can be fixed by changing `demo` so that the destructor does -not run while the string-data is borrowed; for example by taking `S` -by reference: - -``` -pub struct S<'a> { data: &'a mut String } - -impl<'a> Drop for S<'a> { - fn drop(&mut self) { self.data.push_str("being dropped"); } -} - -fn demo<'a>(s: &'a mut S<'a>) -> &'a mut String { let p = &mut *(*s).data; p } -``` - -Note that this approach needs a reference to S with lifetime `'a`. -Nothing shorter than `'a` will suffice: a shorter lifetime would imply -that after `demo` finishes executing, something else (such as the -destructor!) could access `s.data` after the end of that shorter -lifetime, which would again violate the `&mut`-borrow's exclusive -access. -"##, - -E0716: r##" -This error indicates that a temporary value is being dropped -while a borrow is still in active use. - -Erroneous code example: - -```compile_fail,E0716 -fn foo() -> i32 { 22 } -fn bar(x: &i32) -> &i32 { x } -let p = bar(&foo()); - // ------ creates a temporary -let q = *p; -``` - -Here, the expression `&foo()` is borrowing the expression -`foo()`. As `foo()` is a call to a function, and not the name of -a variable, this creates a **temporary** -- that temporary stores -the return value from `foo()` so that it can be borrowed. -You could imagine that `let p = bar(&foo());` is equivalent -to this: - -```compile_fail,E0597 -# fn foo() -> i32 { 22 } -# fn bar(x: &i32) -> &i32 { x } -let p = { - let tmp = foo(); // the temporary - bar(&tmp) -}; // <-- tmp is freed as we exit this block -let q = p; -``` - -Whenever a temporary is created, it is automatically dropped (freed) -according to fixed rules. Ordinarily, the temporary is dropped -at the end of the enclosing statement -- in this case, after the `let`. -This is illustrated in the example above by showing that `tmp` would -be freed as we exit the block. - -To fix this problem, you need to create a local variable -to store the value in rather than relying on a temporary. -For example, you might change the original program to -the following: - -``` -fn foo() -> i32 { 22 } -fn bar(x: &i32) -> &i32 { x } -let value = foo(); // dropped at the end of the enclosing block -let p = bar(&value); -let q = *p; -``` - -By introducing the explicit `let value`, we allocate storage -that will last until the end of the enclosing block (when `value` -goes out of scope). When we borrow `&value`, we are borrowing a -local variable that already exists, and hence no temporary is created. - -Temporaries are not always dropped at the end of the enclosing -statement. In simple cases where the `&` expression is immediately -stored into a variable, the compiler will automatically extend -the lifetime of the temporary until the end of the enclosing -block. Therefore, an alternative way to fix the original -program is to write `let tmp = &foo()` and not `let tmp = foo()`: - -``` -fn foo() -> i32 { 22 } -fn bar(x: &i32) -> &i32 { x } -let value = &foo(); -let p = bar(value); -let q = *p; -``` - -Here, we are still borrowing `foo()`, but as the borrow is assigned -directly into a variable, the temporary will not be dropped until -the end of the enclosing block. Similar rules apply when temporaries -are stored into aggregate structures like a tuple or struct: - -``` -// Here, two temporaries are created, but -// as they are stored directly into `value`, -// they are not dropped until the end of the -// enclosing block. -fn foo() -> i32 { 22 } -let value = (&foo(), &foo()); -``` -"##, - -E0723: r##" -An feature unstable in `const` contexts was used. - -Erroneous code example: - -```compile_fail,E0723 -trait T {} - -impl T for () {} - -const fn foo() -> impl T { // error: `impl Trait` in const fn is unstable - () -} -``` - -To enable this feature on a nightly version of rustc, add the `const_fn` -feature flag: - -``` -#![feature(const_fn)] - -trait T {} - -impl T for () {} - -const fn foo() -> impl T { - () -} -``` -"##, - -E0729: r##" -Support for Non-Lexical Lifetimes (NLL) has been included in the Rust compiler -since 1.31, and has been enabled on the 2015 edition since 1.36. The new borrow -checker for NLL uncovered some bugs in the old borrow checker, which in some -cases allowed unsound code to compile, resulting in memory safety issues. - -### What do I do? - -Change your code so the warning does no longer trigger. For backwards -compatibility, this unsound code may still compile (with a warning) right now. -However, at some point in the future, the compiler will no longer accept this -code and will throw a hard error. - -### Shouldn't you fix the old borrow checker? - -The old borrow checker has known soundness issues that are basically impossible -to fix. The new NLL-based borrow checker is the fix. - -### Can I turn these warnings into errors by denying a lint? - -No. - -### When are these warnings going to turn into errors? - -No formal timeline for turning the warnings into errors has been set. See -[GitHub issue 58781](https://github.com/rust-lang/rust/issues/58781) for more -information. - -### Why do I get this message with code that doesn't involve borrowing? - -There are some known bugs that trigger this message. -"##, - -; - -// E0008, // cannot bind by-move into a pattern guard -// E0298, // cannot compare constants -// E0299, // mismatched types between arms -// E0471, // constant evaluation error (in pattern) -// E0385, // {} in an aliasable location - E0521, // borrowed data escapes outside of closure -// E0526, // shuffle indices are not constant - E0594, // cannot assign to {} -// E0598, // lifetime of {} is too short to guarantee its contents can be... - E0625, // thread-local statics cannot be accessed at compile-time -} diff --git a/src/librustc_mir/hair/pattern/check_match.rs b/src/librustc_mir/hair/pattern/check_match.rs index ffb3ae44ae1..30586e95acf 100644 --- a/src/librustc_mir/hair/pattern/check_match.rs +++ b/src/librustc_mir/hair/pattern/check_match.rs @@ -20,6 +20,8 @@ use std::slice; use syntax_pos::{MultiSpan, Span}; +use rustc_error_codes::*; + crate fn check_match(tcx: TyCtxt<'_>, def_id: DefId) { let body_id = match tcx.hir().as_local_hir_id(def_id) { None => return, diff --git a/src/librustc_mir/hair/pattern/mod.rs b/src/librustc_mir/hair/pattern/mod.rs index 3d97ed6bf9b..92c7178da53 100644 --- a/src/librustc_mir/hair/pattern/mod.rs +++ b/src/librustc_mir/hair/pattern/mod.rs @@ -28,6 +28,8 @@ use std::fmt; use syntax::ast; use syntax_pos::{Span, DUMMY_SP}; +use rustc_error_codes::*; + #[derive(Clone, Debug)] pub enum PatternError { AssocConstInPattern(Span), diff --git a/src/librustc_mir/lib.rs b/src/librustc_mir/lib.rs index be3bbf46f1c..6408c896e93 100644 --- a/src/librustc_mir/lib.rs +++ b/src/librustc_mir/lib.rs @@ -35,8 +35,6 @@ Rust MIR: a lowered representation of Rust. Also: an experiment! #[macro_use] extern crate rustc_data_structures; #[macro_use] extern crate syntax; -pub mod error_codes; - mod borrow_check; mod build; pub mod dataflow; diff --git a/src/librustc_mir/transform/check_consts/ops.rs b/src/librustc_mir/transform/check_consts/ops.rs index 4b374cff809..303c3984f7c 100644 --- a/src/librustc_mir/transform/check_consts/ops.rs +++ b/src/librustc_mir/transform/check_consts/ops.rs @@ -10,6 +10,8 @@ use syntax_pos::{Span, Symbol}; use super::{ConstKind, Item}; +use rustc_error_codes::*; + /// An operation that is not *always* allowed in a const context. pub trait NonConstOp: std::fmt::Debug { /// Whether this operation can be evaluated by miri. diff --git a/src/librustc_mir/transform/check_unsafety.rs b/src/librustc_mir/transform/check_unsafety.rs index e29239a4536..9374109c82e 100644 --- a/src/librustc_mir/transform/check_unsafety.rs +++ b/src/librustc_mir/transform/check_unsafety.rs @@ -18,6 +18,8 @@ use std::ops::Bound; use crate::util; +use rustc_error_codes::*; + pub struct UnsafetyChecker<'a, 'tcx> { body: &'a Body<'tcx>, const_context: bool, diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs index fd30be807b9..185a499bf48 100644 --- a/src/librustc_mir/transform/qualify_consts.rs +++ b/src/librustc_mir/transform/qualify_consts.rs @@ -31,6 +31,8 @@ use rustc::hir::HirId; use crate::transform::{MirPass, MirSource}; use crate::transform::check_consts::ops::{self, NonConstOp}; +use rustc_error_codes::*; + /// What kind of item we are in. #[derive(Copy, Clone, Debug, PartialEq, Eq)] enum Mode { diff --git a/src/librustc_mir/util/borrowck_errors.rs b/src/librustc_mir/util/borrowck_errors.rs index bf01ad1a023..9004b5e7237 100644 --- a/src/librustc_mir/util/borrowck_errors.rs +++ b/src/librustc_mir/util/borrowck_errors.rs @@ -2,6 +2,8 @@ use rustc::ty::{self, Ty, TyCtxt}; use rustc_errors::{DiagnosticBuilder, DiagnosticId}; use syntax_pos::{MultiSpan, Span}; +use rustc_error_codes::*; + impl<'cx, 'tcx> crate::borrow_check::MirBorrowckCtxt<'cx, 'tcx> { crate fn cannot_move_when_borrowed( &self, diff --git a/src/librustc_parse/Cargo.toml b/src/librustc_parse/Cargo.toml index 4579f9d472d..a9175487a75 100644 --- a/src/librustc_parse/Cargo.toml +++ b/src/librustc_parse/Cargo.toml @@ -19,3 +19,4 @@ rustc_data_structures = { path = "../librustc_data_structures" } rustc_lexer = { path = "../librustc_lexer" } rustc_target = { path = "../librustc_target" } smallvec = { version = "1.0", features = ["union", "may_dangle"] } +rustc_error_codes = { path = "../librustc_error_codes" } diff --git a/src/librustc_parse/error_codes.rs b/src/librustc_parse/error_codes.rs deleted file mode 100644 index cf74e09a377..00000000000 --- a/src/librustc_parse/error_codes.rs +++ /dev/null @@ -1,174 +0,0 @@ -// Error messages for EXXXX errors. -// Each message should start and end with a new line, and be wrapped to 80 -// characters. In vim you can `:set tw=80` and use `gq` to wrap paragraphs. Use -// `:set tw=0` to disable. -syntax::register_diagnostics! { - -E0178: r##" -In types, the `+` type operator has low precedence, so it is often necessary -to use parentheses. - -For example: - -```compile_fail,E0178 -trait Foo {} - -struct Bar<'a> { - w: &'a Foo + Copy, // error, use &'a (Foo + Copy) - x: &'a Foo + 'a, // error, use &'a (Foo + 'a) - y: &'a mut Foo + 'a, // error, use &'a mut (Foo + 'a) - z: fn() -> Foo + 'a, // error, use fn() -> (Foo + 'a) -} -``` - -More details can be found in [RFC 438]. - -[RFC 438]: https://github.com/rust-lang/rfcs/pull/438 -"##, - -E0583: r##" -A file wasn't found for an out-of-line module. - -Erroneous code example: - -```ignore (compile_fail not working here; see Issue #43707) -mod file_that_doesnt_exist; // error: file not found for module - -fn main() {} -``` - -Please be sure that a file corresponding to the module exists. If you -want to use a module named `file_that_doesnt_exist`, you need to have a file -named `file_that_doesnt_exist.rs` or `file_that_doesnt_exist/mod.rs` in the -same directory. -"##, - -E0584: r##" -A doc comment that is not attached to anything has been encountered. - -Erroneous code example: - -```compile_fail,E0584 -trait Island { - fn lost(); - - /// I'm lost! -} -``` - -A little reminder: a doc comment has to be placed before the item it's supposed -to document. So if you want to document the `Island` trait, you need to put a -doc comment before it, not inside it. Same goes for the `lost` method: the doc -comment needs to be before it: - -``` -/// I'm THE island! -trait Island { - /// I'm lost! - fn lost(); -} -``` -"##, - -E0585: r##" -A documentation comment that doesn't document anything was found. - -Erroneous code example: - -```compile_fail,E0585 -fn main() { - // The following doc comment will fail: - /// This is a useless doc comment! -} -``` - -Documentation comments need to be followed by items, including functions, -types, modules, etc. Examples: - -``` -/// I'm documenting the following struct: -struct Foo; - -/// I'm documenting the following function: -fn foo() {} -``` -"##, - -E0586: r##" -An inclusive range was used with no end. - -Erroneous code example: - -```compile_fail,E0586 -fn main() { - let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1]; - let x = &tmp[1..=]; // error: inclusive range was used with no end -} -``` - -An inclusive range needs an end in order to *include* it. If you just need a -start and no end, use a non-inclusive range (with `..`): - -``` -fn main() { - let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1]; - let x = &tmp[1..]; // ok! -} -``` - -Or put an end to your inclusive range: - -``` -fn main() { - let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1]; - let x = &tmp[1..=3]; // ok! -} -``` -"##, - -E0704: r##" -This error indicates that a incorrect visibility restriction was specified. - -Example of erroneous code: - -```compile_fail,E0704 -mod foo { - pub(foo) struct Bar { - x: i32 - } -} -``` - -To make struct `Bar` only visible in module `foo` the `in` keyword should be -used: -``` -mod foo { - pub(in crate::foo) struct Bar { - x: i32 - } -} -# fn main() {} -``` - -For more information see the Rust Reference on [Visibility]. - -[Visibility]: https://doc.rust-lang.org/reference/visibility-and-privacy.html -"##, - -E0743: r##" -C-variadic has been used on a non-foreign function. - -Erroneous code example: - -```compile_fail,E0743 -fn foo2(x: u8, ...) {} // error! -``` - -Only foreign functions can use C-variadic (`...`). It is used to give an -undefined number of parameters to a given function (like `printf` in C). The -equivalent in Rust would be to use macros directly. -"##, - -; - -} diff --git a/src/librustc_parse/lib.rs b/src/librustc_parse/lib.rs index 9f507d5319e..3a983404220 100644 --- a/src/librustc_parse/lib.rs +++ b/src/librustc_parse/lib.rs @@ -25,7 +25,6 @@ pub mod parser; use parser::{Parser, emit_unclosed_delims, make_unclosed_delims_error}; pub mod lexer; pub mod validate_attr; -pub mod error_codes; #[derive(Clone)] pub struct Directory<'a> { diff --git a/src/librustc_parse/parser/diagnostics.rs b/src/librustc_parse/parser/diagnostics.rs index 38eae008537..5036759da3f 100644 --- a/src/librustc_parse/parser/diagnostics.rs +++ b/src/librustc_parse/parser/diagnostics.rs @@ -12,12 +12,14 @@ use syntax::ThinVec; use syntax::util::parser::AssocOp; use syntax::struct_span_err; -use errors::{PResult, Applicability, DiagnosticBuilder, DiagnosticId, pluralize}; +use errors::{PResult, Applicability, DiagnosticBuilder, pluralize}; use rustc_data_structures::fx::FxHashSet; use syntax_pos::{Span, DUMMY_SP, MultiSpan, SpanSnippetError}; use log::{debug, trace}; use std::mem; +use rustc_error_codes::*; + const TURBOFISH: &'static str = "use `::<...>` instead of `<...>` to specify type arguments"; /// Creates a placeholder argument. @@ -1411,19 +1413,19 @@ impl<'a> Parser<'a> { self.expect(&token::Colon)?; let ty = self.parse_ty()?; - self.diagnostic() - .struct_span_err_with_code( - pat.span, - "patterns aren't allowed in methods without bodies", - DiagnosticId::Error("E0642".into()), - ) - .span_suggestion_short( - pat.span, - "give this argument a name or use an underscore to ignore it", - "_".to_owned(), - Applicability::MachineApplicable, - ) - .emit(); + struct_span_err!( + self.diagnostic(), + pat.span, + E0642, + "patterns aren't allowed in methods without bodies", + ) + .span_suggestion_short( + pat.span, + "give this argument a name or use an underscore to ignore it", + "_".to_owned(), + Applicability::MachineApplicable, + ) + .emit(); // Pretend the pattern is `_`, to avoid duplicate errors from AST validation. let pat = P(Pat { diff --git a/src/librustc_parse/parser/item.rs b/src/librustc_parse/parser/item.rs index 1f386b8bbbf..cb496f2ecbe 100644 --- a/src/librustc_parse/parser/item.rs +++ b/src/librustc_parse/parser/item.rs @@ -14,12 +14,15 @@ use syntax::ThinVec; use syntax::token; use syntax::tokenstream::{TokenTree, TokenStream}; use syntax::source_map::{self, respan, Span}; +use syntax::struct_span_err; use syntax_pos::BytePos; use syntax_pos::symbol::{kw, sym}; +use rustc_error_codes::*; + use log::debug; use std::mem; -use errors::{PResult, Applicability, DiagnosticBuilder, DiagnosticId, StashKey}; +use errors::{PResult, Applicability, DiagnosticBuilder, StashKey}; /// Whether the type alias or associated type is a concrete type or an opaque type. #[derive(Debug)] @@ -842,10 +845,11 @@ impl<'a> Parser<'a> { if let token::DocComment(_) = self.token.kind { if self.look_ahead(1, |tok| tok == &token::CloseDelim(token::Brace)) { - self.diagnostic().struct_span_err_with_code( + struct_span_err!( + self.diagnostic(), self.token.span, + E0584, "found a documentation comment that doesn't document anything", - DiagnosticId::Error("E0584".into()), ) .help( "doc comments must come before what they document, maybe a \ diff --git a/src/librustc_parse/parser/mod.rs b/src/librustc_parse/parser/mod.rs index d5d8604be85..f62f0c9a268 100644 --- a/src/librustc_parse/parser/mod.rs +++ b/src/librustc_parse/parser/mod.rs @@ -30,13 +30,15 @@ use syntax::util::comments::{doc_comment_style, strip_doc_comment_decoration}; use syntax_pos::symbol::{kw, sym, Symbol}; use syntax_pos::{Span, BytePos, DUMMY_SP, FileName}; use rustc_data_structures::thin_vec::ThinVec; -use errors::{PResult, Applicability, DiagnosticBuilder, DiagnosticId, FatalError}; +use errors::{PResult, Applicability, DiagnosticBuilder, FatalError}; use log::debug; use std::borrow::Cow; use std::{cmp, mem, slice}; use std::path::PathBuf; +use rustc_error_codes::*; + bitflags::bitflags! { struct Restrictions: u8 { const STMT_EXPR = 1 << 0; @@ -1249,13 +1251,13 @@ impl<'a> Parser<'a> { /// We are parsing `async fn`. If we are on Rust 2015, emit an error. fn ban_async_in_2015(&self, async_span: Span) { if async_span.rust_2015() { - self.diagnostic() - .struct_span_err_with_code( - async_span, - "`async fn` is not permitted in the 2015 edition", - DiagnosticId::Error("E0670".into()) - ) - .emit(); + struct_span_err!( + self.diagnostic(), + async_span, + E0670, + "`async fn` is not permitted in the 2015 edition", + ) + .emit(); } } diff --git a/src/librustc_parse/parser/ty.rs b/src/librustc_parse/parser/ty.rs index fccabee2404..4c7d1006183 100644 --- a/src/librustc_parse/parser/ty.rs +++ b/src/librustc_parse/parser/ty.rs @@ -14,6 +14,8 @@ use syntax_pos::symbol::kw; use errors::{PResult, Applicability, pluralize}; +use rustc_error_codes::*; + /// Returns `true` if `IDENT t` can start a type -- `IDENT::a::b`, `IDENT<u8, u8>`, /// `IDENT<<u8 as Trait>::AssocTy>`. /// diff --git a/src/librustc_passes/Cargo.toml b/src/librustc_passes/Cargo.toml index 556189208f1..7a98734bdbe 100644 --- a/src/librustc_passes/Cargo.toml +++ b/src/librustc_passes/Cargo.toml @@ -18,3 +18,4 @@ rustc_target = { path = "../librustc_target" } syntax = { path = "../libsyntax" } syntax_pos = { path = "../libsyntax_pos" } errors = { path = "../librustc_errors", package = "rustc_errors" } +rustc_error_codes = { path = "../librustc_error_codes" } diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs index ec5572914d8..c48d2c61e65 100644 --- a/src/librustc_passes/ast_validation.rs +++ b/src/librustc_passes/ast_validation.rs @@ -23,6 +23,8 @@ use syntax::{span_err, struct_span_err, walk_list}; use syntax_pos::{Span, MultiSpan}; use errors::{Applicability, FatalError}; +use rustc_error_codes::*; + struct AstValidator<'a> { session: &'a Session, has_proc_macro_decls: bool, diff --git a/src/librustc_passes/check_const.rs b/src/librustc_passes/check_const.rs index a6d7eeabc88..9d37b4bdb76 100644 --- a/src/librustc_passes/check_const.rs +++ b/src/librustc_passes/check_const.rs @@ -17,6 +17,7 @@ use rustc::ty::query::Providers; use syntax::ast::Mutability; use syntax::span_err; use syntax_pos::Span; +use rustc_error_codes::*; use std::fmt; diff --git a/src/librustc_passes/entry.rs b/src/librustc_passes/entry.rs index 66004719060..d0cedc08162 100644 --- a/src/librustc_passes/entry.rs +++ b/src/librustc_passes/entry.rs @@ -11,6 +11,8 @@ use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::ty::TyCtxt; use rustc::ty::query::Providers; +use rustc_error_codes::*; + struct EntryContext<'a, 'tcx> { session: &'a Session, diff --git a/src/librustc_passes/error_codes.rs b/src/librustc_passes/error_codes.rs deleted file mode 100644 index 72cf0c7ed77..00000000000 --- a/src/librustc_passes/error_codes.rs +++ /dev/null @@ -1,657 +0,0 @@ -syntax::register_diagnostics! { -E0014: r##" -#### Note: this error code is no longer emitted by the compiler. - -Constants can only be initialized by a constant value or, in a future -version of Rust, a call to a const function. This error indicates the use -of a path (like a::b, or x) denoting something other than one of these -allowed items. - -Erroneous code example: - -``` -const FOO: i32 = { let x = 0; x }; // 'x' isn't a constant nor a function! -``` - -To avoid it, you have to replace the non-constant value: - -``` -const FOO: i32 = { const X : i32 = 0; X }; -// or even: -const FOO2: i32 = { 0 }; // but brackets are useless here -``` -"##, - -E0130: r##" -You declared a pattern as an argument in a foreign function declaration. - -Erroneous code example: - -```compile_fail -extern { - fn foo((a, b): (u32, u32)); // error: patterns aren't allowed in foreign - // function declarations -} -``` - -Please replace the pattern argument with a regular one. Example: - -``` -struct SomeStruct { - a: u32, - b: u32, -} - -extern { - fn foo(s: SomeStruct); // ok! -} -``` - -Or: - -``` -extern { - fn foo(a: (u32, u32)); // ok! -} -``` -"##, - -// This shouldn't really ever trigger since the repeated value error comes first -E0136: r##" -A binary can only have one entry point, and by default that entry point is the -function `main()`. If there are multiple such functions, please rename one. - -Erroneous code example: - -```compile_fail,E0136 -fn main() { - // ... -} - -// ... - -fn main() { // error! - // ... -} -``` -"##, - -E0137: r##" -More than one function was declared with the `#[main]` attribute. - -Erroneous code example: - -```compile_fail,E0137 -#![feature(main)] - -#[main] -fn foo() {} - -#[main] -fn f() {} // error: multiple functions with a `#[main]` attribute -``` - -This error indicates that the compiler found multiple functions with the -`#[main]` attribute. This is an error because there must be a unique entry -point into a Rust program. Example: - -``` -#![feature(main)] - -#[main] -fn f() {} // ok! -``` -"##, - -E0138: r##" -More than one function was declared with the `#[start]` attribute. - -Erroneous code example: - -```compile_fail,E0138 -#![feature(start)] - -#[start] -fn foo(argc: isize, argv: *const *const u8) -> isize {} - -#[start] -fn f(argc: isize, argv: *const *const u8) -> isize {} -// error: multiple 'start' functions -``` - -This error indicates that the compiler found multiple functions with the -`#[start]` attribute. This is an error because there must be a unique entry -point into a Rust program. Example: - -``` -#![feature(start)] - -#[start] -fn foo(argc: isize, argv: *const *const u8) -> isize { 0 } // ok! -``` -"##, - -E0197: r##" -Inherent implementations (one that do not implement a trait but provide -methods associated with a type) are always safe because they are not -implementing an unsafe trait. Removing the `unsafe` keyword from the inherent -implementation will resolve this error. - -```compile_fail,E0197 -struct Foo; - -// this will cause this error -unsafe impl Foo { } -// converting it to this will fix it -impl Foo { } -``` -"##, - -E0198: r##" -A negative implementation is one that excludes a type from implementing a -particular trait. Not being able to use a trait is always a safe operation, -so negative implementations are always safe and never need to be marked as -unsafe. - -```compile_fail -#![feature(optin_builtin_traits)] - -struct Foo; - -// unsafe is unnecessary -unsafe impl !Clone for Foo { } -``` - -This will compile: - -```ignore (ignore auto_trait future compatibility warning) -#![feature(optin_builtin_traits)] - -struct Foo; - -auto trait Enterprise {} - -impl !Enterprise for Foo { } -``` - -Please note that negative impls are only allowed for auto traits. -"##, - -E0267: r##" -This error indicates the use of a loop keyword (`break` or `continue`) inside a -closure but outside of any loop. Erroneous code example: - -```compile_fail,E0267 -let w = || { break; }; // error: `break` inside of a closure -``` - -`break` and `continue` keywords can be used as normal inside closures as long as -they are also contained within a loop. To halt the execution of a closure you -should instead use a return statement. Example: - -``` -let w = || { - for _ in 0..10 { - break; - } -}; - -w(); -``` -"##, - -E0268: r##" -This error indicates the use of a loop keyword (`break` or `continue`) outside -of a loop. Without a loop to break out of or continue in, no sensible action can -be taken. Erroneous code example: - -```compile_fail,E0268 -fn some_func() { - break; // error: `break` outside of a loop -} -``` - -Please verify that you are using `break` and `continue` only in loops. Example: - -``` -fn some_func() { - for _ in 0..10 { - break; // ok! - } -} -``` -"##, - -E0379: r##" -Trait methods cannot be declared `const` by design. For more information, see -[RFC 911]. - -[RFC 911]: https://github.com/rust-lang/rfcs/pull/911 -"##, - -E0380: r##" -Auto traits cannot have methods or associated items. -For more information see the [opt-in builtin traits RFC][RFC 19]. - -[RFC 19]: https://github.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md -"##, - -E0449: r##" -A visibility qualifier was used when it was unnecessary. Erroneous code -examples: - -```compile_fail,E0449 -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 -impl Foo for Bar { - fn foo() {} -} -``` -"##, - -E0512: r##" -Transmute with two differently sized types was attempted. Erroneous code -example: - -```compile_fail,E0512 -fn takes_u8(_: u8) {} - -fn main() { - unsafe { takes_u8(::std::mem::transmute(0u16)); } - // error: cannot transmute between types of different sizes, - // or dependently-sized types -} -``` - -Please use types with same size or use the expected type directly. Example: - -``` -fn takes_u8(_: u8) {} - -fn main() { - unsafe { takes_u8(::std::mem::transmute(0i8)); } // ok! - // or: - unsafe { takes_u8(0u8); } // ok! -} -``` -"##, - -E0561: r##" -A non-ident or non-wildcard pattern has been used as a parameter of a function -pointer type. - -Erroneous code example: - -```compile_fail,E0561 -type A1 = fn(mut param: u8); // error! -type A2 = fn(¶m: u32); // error! -``` - -When using an alias over a function type, you cannot e.g. denote a parameter as -being mutable. - -To fix the issue, remove patterns (`_` is allowed though). Example: - -``` -type A1 = fn(param: u8); // ok! -type A2 = fn(_: u32); // ok! -``` - -You can also omit the parameter name: - -``` -type A3 = fn(i16); // ok! -``` -"##, - -E0567: r##" -Generics have been used on an auto trait. - -Erroneous code example: - -```compile_fail,E0567 -#![feature(optin_builtin_traits)] - -auto trait Generic<T> {} // error! - -fn main() {} -``` - -Since an auto trait is implemented on all existing types, the -compiler would not be able to infer the types of the trait's generic -parameters. - -To fix this issue, just remove the generics: - -``` -#![feature(optin_builtin_traits)] - -auto trait Generic {} // ok! - -fn main() {} -``` -"##, - -E0568: r##" -A super trait has been added to an auto trait. - -Erroneous code example: - -```compile_fail,E0568 -#![feature(optin_builtin_traits)] - -auto trait Bound : Copy {} // error! - -fn main() {} -``` - -Since an auto trait is implemented on all existing types, adding a super trait -would filter out a lot of those types. In the current example, almost none of -all the existing types could implement `Bound` because very few of them have the -`Copy` trait. - -To fix this issue, just remove the super trait: - -``` -#![feature(optin_builtin_traits)] - -auto trait Bound {} // ok! - -fn main() {} -``` -"##, - -E0571: r##" -A `break` statement with an argument appeared in a non-`loop` loop. - -Example of erroneous code: - -```compile_fail,E0571 -# let mut i = 1; -# fn satisfied(n: usize) -> bool { n % 23 == 0 } -let result = while true { - if satisfied(i) { - break 2*i; // error: `break` with value from a `while` loop - } - i += 1; -}; -``` - -The `break` statement can take an argument (which will be the value of the loop -expression if the `break` statement is executed) in `loop` loops, but not -`for`, `while`, or `while let` loops. - -Make sure `break value;` statements only occur in `loop` loops: - -``` -# let mut i = 1; -# fn satisfied(n: usize) -> bool { n % 23 == 0 } -let result = loop { // ok! - if satisfied(i) { - break 2*i; - } - i += 1; -}; -``` -"##, - -E0590: r##" -`break` or `continue` must include a label when used in the condition of a -`while` loop. - -Example of erroneous code: - -```compile_fail -while break {} -``` - -To fix this, add a label specifying which loop is being broken out of: -``` -'foo: while break 'foo {} -``` -"##, - -E0591: r##" -Per [RFC 401][rfc401], if you have a function declaration `foo`: - -``` -// For the purposes of this explanation, all of these -// different kinds of `fn` declarations are equivalent: -struct S; -fn foo(x: S) { /* ... */ } -# #[cfg(for_demonstration_only)] -extern "C" { fn foo(x: S); } -# #[cfg(for_demonstration_only)] -impl S { fn foo(self) { /* ... */ } } -``` - -the type of `foo` is **not** `fn(S)`, as one might expect. -Rather, it is a unique, zero-sized marker type written here as `typeof(foo)`. -However, `typeof(foo)` can be _coerced_ to a function pointer `fn(S)`, -so you rarely notice this: - -``` -# struct S; -# fn foo(_: S) {} -let x: fn(S) = foo; // OK, coerces -``` - -The reason that this matter is that the type `fn(S)` is not specific to -any particular function: it's a function _pointer_. So calling `x()` results -in a virtual call, whereas `foo()` is statically dispatched, because the type -of `foo` tells us precisely what function is being called. - -As noted above, coercions mean that most code doesn't have to be -concerned with this distinction. However, you can tell the difference -when using **transmute** to convert a fn item into a fn pointer. - -This is sometimes done as part of an FFI: - -```compile_fail,E0591 -extern "C" fn foo(userdata: Box<i32>) { - /* ... */ -} - -# fn callback(_: extern "C" fn(*mut i32)) {} -# use std::mem::transmute; -# unsafe { -let f: extern "C" fn(*mut i32) = transmute(foo); -callback(f); -# } -``` - -Here, transmute is being used to convert the types of the fn arguments. -This pattern is incorrect because, because the type of `foo` is a function -**item** (`typeof(foo)`), which is zero-sized, and the target type (`fn()`) -is a function pointer, which is not zero-sized. -This pattern should be rewritten. There are a few possible ways to do this: - -- change the original fn declaration to match the expected signature, - and do the cast in the fn body (the preferred option) -- cast the fn item fo a fn pointer before calling transmute, as shown here: - - ``` - # extern "C" fn foo(_: Box<i32>) {} - # use std::mem::transmute; - # unsafe { - let f: extern "C" fn(*mut i32) = transmute(foo as extern "C" fn(_)); - let f: extern "C" fn(*mut i32) = transmute(foo as usize); // works too - # } - ``` - -The same applies to transmutes to `*mut fn()`, which were observed in practice. -Note though that use of this type is generally incorrect. -The intention is typically to describe a function pointer, but just `fn()` -alone suffices for that. `*mut fn()` is a pointer to a fn pointer. -(Since these values are typically just passed to C code, however, this rarely -makes a difference in practice.) - -[rfc401]: https://github.com/rust-lang/rfcs/blob/master/text/0401-coercions.md -"##, - -E0601: r##" -No `main` function was found in a binary crate. To fix this error, add a -`main` function. For example: - -``` -fn main() { - // Your program will start here. - println!("Hello world!"); -} -``` - -If you don't know the basics of Rust, you can go look to the Rust Book to get -started: https://doc.rust-lang.org/book/ -"##, - -E0642: r##" -Trait methods currently cannot take patterns as arguments. - -Example of erroneous code: - -```compile_fail,E0642 -trait Foo { - fn foo((x, y): (i32, i32)); // error: patterns aren't allowed - // in trait methods -} -``` - -You can instead use a single name for the argument: - -``` -trait Foo { - fn foo(x_and_y: (i32, i32)); // ok! -} -``` -"##, - -E0666: r##" -`impl Trait` types cannot appear nested in the -generic arguments of other `impl Trait` types. - -Example of erroneous code: - -```compile_fail,E0666 -trait MyGenericTrait<T> {} -trait MyInnerTrait {} - -fn foo(bar: impl MyGenericTrait<impl MyInnerTrait>) {} -``` - -Type parameters for `impl Trait` types must be -explicitly defined as named generic parameters: - -``` -trait MyGenericTrait<T> {} -trait MyInnerTrait {} - -fn foo<T: MyInnerTrait>(bar: impl MyGenericTrait<T>) {} -``` -"##, - -E0695: r##" -A `break` statement without a label appeared inside a labeled block. - -Example of erroneous code: - -```compile_fail,E0695 -# #![feature(label_break_value)] -loop { - 'a: { - break; - } -} -``` - -Make sure to always label the `break`: - -``` -# #![feature(label_break_value)] -'l: loop { - 'a: { - break 'l; - } -} -``` - -Or if you want to `break` the labeled block: - -``` -# #![feature(label_break_value)] -loop { - 'a: { - break 'a; - } - break; -} -``` -"##, - -E0670: r##" -Rust 2015 does not permit the use of `async fn`. - -Example of erroneous code: - -```compile_fail,E0670 -async fn foo() {} -``` - -Switch to the Rust 2018 edition to use `async fn`. -"##, - -E0744: r##" -Control-flow expressions are not allowed inside a const context. - -At the moment, `if` and `match`, as well as the looping constructs `for`, -`while`, and `loop`, are forbidden inside a `const`, `static`, or `const fn`. - -```compile_fail,E0744 -const _: i32 = { - let mut x = 0; - loop { - x += 1; - if x == 4 { - break; - } - } - - x -}; -``` - -"##, - -; - E0226, // only a single explicit lifetime bound is permitted - E0472, // asm! is unsupported on this target - E0667, // `impl Trait` in projections - E0696, // `continue` pointing to a labeled block - E0706, // `async fn` in trait -} diff --git a/src/librustc_passes/intrinsicck.rs b/src/librustc_passes/intrinsicck.rs index 91a7e9f5d7f..96071b721b9 100644 --- a/src/librustc_passes/intrinsicck.rs +++ b/src/librustc_passes/intrinsicck.rs @@ -10,6 +10,8 @@ use syntax_pos::{Span, sym}; use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap}; use rustc::hir; +use rustc_error_codes::*; + fn check_mod_intrinsics(tcx: TyCtxt<'_>, module_def_id: DefId) { tcx.hir().visit_item_likes_in_module( module_def_id, diff --git a/src/librustc_passes/lib.rs b/src/librustc_passes/lib.rs index 1cbe6a652af..81f06a14d95 100644 --- a/src/librustc_passes/lib.rs +++ b/src/librustc_passes/lib.rs @@ -20,8 +20,6 @@ extern crate syntax; use rustc::ty::query::Providers; -pub mod error_codes; - pub mod ast_validation; mod check_const; pub mod hir_stats; diff --git a/src/librustc_passes/loops.rs b/src/librustc_passes/loops.rs index 60525ba6b39..6140d0438d8 100644 --- a/src/librustc_passes/loops.rs +++ b/src/librustc_passes/loops.rs @@ -12,6 +12,8 @@ use syntax::struct_span_err; use syntax_pos::Span; use errors::Applicability; +use rustc_error_codes::*; + #[derive(Clone, Copy, Debug, PartialEq)] enum Context { Normal, diff --git a/src/librustc_plugin/Cargo.toml b/src/librustc_plugin/Cargo.toml index e8bf4e7ea8f..c57b32fb2b6 100644 --- a/src/librustc_plugin/Cargo.toml +++ b/src/librustc_plugin/Cargo.toml @@ -16,3 +16,4 @@ rustc_metadata = { path = "../librustc_metadata" } syntax = { path = "../libsyntax" } syntax_expand = { path = "../libsyntax_expand" } syntax_pos = { path = "../libsyntax_pos" } +rustc_error_codes = { path = "../librustc_error_codes" } diff --git a/src/librustc_plugin/error_codes.rs b/src/librustc_plugin/error_codes.rs deleted file mode 100644 index 7b3f01c0ee1..00000000000 --- a/src/librustc_plugin/error_codes.rs +++ /dev/null @@ -1,4 +0,0 @@ -syntax::register_diagnostics! { -; - E0498, // malformed plugin attribute -} diff --git a/src/librustc_plugin/lib.rs b/src/librustc_plugin/lib.rs index 38738e20630..83e9ebeb935 100644 --- a/src/librustc_plugin/lib.rs +++ b/src/librustc_plugin/lib.rs @@ -59,7 +59,6 @@ pub use registry::Registry; -pub mod error_codes; pub mod registry; pub mod load; pub mod build; diff --git a/src/librustc_plugin/load.rs b/src/librustc_plugin/load.rs index 8ceb56b0fd2..31b3b07c3e1 100644 --- a/src/librustc_plugin/load.rs +++ b/src/librustc_plugin/load.rs @@ -14,6 +14,8 @@ use syntax::struct_span_err; use syntax::symbol::{Symbol, kw, sym}; use syntax_pos::{Span, DUMMY_SP}; +use rustc_error_codes::*; + /// Pointer to a registrar function. pub type PluginRegistrarFun = fn(&mut Registry<'_>); diff --git a/src/librustc_privacy/Cargo.toml b/src/librustc_privacy/Cargo.toml index 7cf3a5d6dcd..ef974c77aca 100644 --- a/src/librustc_privacy/Cargo.toml +++ b/src/librustc_privacy/Cargo.toml @@ -14,4 +14,5 @@ rustc_typeck = { path = "../librustc_typeck" } syntax = { path = "../libsyntax" } syntax_pos = { path = "../libsyntax_pos" } rustc_data_structures = { path = "../librustc_data_structures" } +rustc_error_codes = { path = "../librustc_error_codes" } log = "0.4" diff --git a/src/librustc_privacy/error_codes.rs b/src/librustc_privacy/error_codes.rs deleted file mode 100644 index 03afb547d3a..00000000000 --- a/src/librustc_privacy/error_codes.rs +++ /dev/null @@ -1,169 +0,0 @@ -syntax::register_diagnostics! { - -E0445: r##" -A private trait was used on a public type parameter bound. - -Erroneous code examples: - -```compile_fail,E0445 -#![deny(private_in_public)] - -trait Foo { - fn dummy(&self) { } -} - -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. 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: - -``` -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 a public type signature. - -Erroneous code example: - -```compile_fail,E0446 -#![deny(private_in_public)] - -mod Foo { - struct Bar(u32); - - pub fn bar() -> Bar { // error: private type in public interface - Bar(0) - } -} -``` - -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 { - pub struct Bar(u32); // we set the Bar type public - - pub fn bar() -> Bar { // ok! - Bar(0) - } -} -``` -"##, - -E0447: r##" -#### Note: this error code is no longer emitted by the compiler. - -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##" -#### Note: this error code is no longer emitted by the compiler. - -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, // not ok! -} -``` - -This is the correct syntax: - -``` -pub enum Foo { - Bar, // ok! -} -``` -"##, - -E0451: r##" -A struct constructor with private fields was invoked. - -Erroneous code example: - -```compile_fail,E0451 -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! -``` -"##, - -// E0450, moved into resolve -} diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 34cdec229af..8c4b4c16510 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -30,7 +30,7 @@ use syntax_pos::Span; use std::{cmp, fmt, mem}; use std::marker::PhantomData; -pub mod error_codes; +use rustc_error_codes::*; //////////////////////////////////////////////////////////////////////////////// /// Generic infrastructure used to implement specific visitors below. diff --git a/src/librustc_resolve/Cargo.toml b/src/librustc_resolve/Cargo.toml index 33b2bd36b7d..6cce893f8ec 100644 --- a/src/librustc_resolve/Cargo.toml +++ b/src/librustc_resolve/Cargo.toml @@ -21,4 +21,5 @@ errors = { path = "../librustc_errors", package = "rustc_errors" } syntax_pos = { path = "../libsyntax_pos" } rustc_data_structures = { path = "../librustc_data_structures" } rustc_metadata = { path = "../librustc_metadata" } +rustc_error_codes = { path = "../librustc_error_codes" } smallvec = { version = "1.0", features = ["union", "may_dangle"] } diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 0fcac5aab62..fa7c2cdda68 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -46,6 +46,8 @@ use syntax_pos::{Span, DUMMY_SP}; use log::debug; +use rustc_error_codes::*; + type Res = def::Res<NodeId>; impl<'a> ToNameBinding<'a> for (Module<'a>, ty::Visibility, Span, ExpnId) { diff --git a/src/librustc_resolve/diagnostics.rs b/src/librustc_resolve/diagnostics.rs index 771519b86c1..1ebe9b5e120 100644 --- a/src/librustc_resolve/diagnostics.rs +++ b/src/librustc_resolve/diagnostics.rs @@ -1,6 +1,6 @@ use std::cmp::Reverse; -use errors::{Applicability, DiagnosticBuilder, DiagnosticId}; +use errors::{Applicability, DiagnosticBuilder}; use log::debug; use rustc::bug; use rustc::hir::def::{self, DefKind, NonMacroAttrKind}; @@ -23,6 +23,8 @@ use crate::path_names_to_string; use crate::{BindingError, CrateLint, HasGenericParams, LegacyScope, Module, ModuleOrUniformRoot}; use crate::{PathResult, ParentScope, ResolutionError, Resolver, Scope, ScopeSet, Segment}; +use rustc_error_codes::*; + type Res = def::Res<ast::NodeId>; /// A vector of spans and replacements, a message and applicability. @@ -205,11 +207,11 @@ impl<'a> Resolver<'a> { let origin_sp = origin.iter().copied().collect::<Vec<_>>(); let msp = MultiSpan::from_spans(target_sp.clone()); - let msg = format!("variable `{}` is not bound in all patterns", name); - let mut err = self.session.struct_span_err_with_code( + let mut err = struct_span_err!( + self.session, msp, - &msg, - DiagnosticId::Error("E0408".into()), + E0408, + "variable `{}` is not bound in all patterns", name, ); for sp in target_sp { err.span_label(sp, format!("pattern doesn't bind `{}`", name)); diff --git a/src/librustc_resolve/error_codes.rs b/src/librustc_resolve/error_codes.rs deleted file mode 100644 index c59959ae4f4..00000000000 --- a/src/librustc_resolve/error_codes.rs +++ /dev/null @@ -1,2048 +0,0 @@ -// Error messages for EXXXX errors. Each message should start and end with a -// new line, and be wrapped to 80 characters. In vim you can `:set tw=80` and -// use `gq` to wrap paragraphs. Use `:set tw=0` to disable. -syntax::register_diagnostics! { - -E0128: r##" -Type parameter defaults can only use parameters that occur before them. -Erroneous code example: - -```compile_fail,E0128 -struct Foo<T = U, U = ()> { - field1: T, - field2: U, -} -// error: type parameters with a default cannot use forward declared -// identifiers -``` - -Since type parameters are evaluated in-order, you may be able to fix this issue -by doing: - -``` -struct Foo<U = (), T = U> { - field1: T, - field2: U, -} -``` - -Please also verify that this wasn't because of a name-clash and rename the type -parameter if so. -"##, - -E0154: r##" -#### Note: this error code is no longer emitted by the compiler. - -Imports (`use` statements) are not allowed after non-item statements, such as -variable declarations and expression statements. - -Here is an example that demonstrates the error: - -``` -fn f() { - // Variable declaration before import - let x = 0; - use std::io::Read; - // ... -} -``` - -The solution is to declare the imports at the top of the block, function, or -file. - -Here is the previous example again, with the correct order: - -``` -fn f() { - use std::io::Read; - let x = 0; - // ... -} -``` - -See the Declaration Statements section of the reference for more information -about what constitutes an Item declaration and what does not: - -https://doc.rust-lang.org/reference.html#statements -"##, - -E0251: r##" -#### Note: this error code is no longer emitted by the compiler. - -Two items of the same name cannot be imported without rebinding one of the -items under a new local name. - -An example of this error: - -``` -use foo::baz; -use bar::*; // error, do `use foo::baz as quux` instead on the previous line - -fn main() {} - -mod foo { - pub struct baz; -} - -mod bar { - pub mod baz {} -} -``` -"##, - -E0252: r##" -Two items of the same name cannot be imported without rebinding one of the -items under a new local name. - -Erroneous code example: - -```compile_fail,E0252 -use foo::baz; -use bar::baz; // error, do `use bar::baz as quux` instead - -fn main() {} - -mod foo { - pub struct baz; -} - -mod bar { - pub mod baz {} -} -``` - -You can use aliases in order to fix this error. Example: - -``` -use foo::baz as foo_baz; -use bar::baz; // ok! - -fn main() {} - -mod foo { - pub struct baz; -} - -mod bar { - pub mod baz {} -} -``` - -Or you can reference the item with its parent: - -``` -use bar::baz; - -fn main() { - let x = foo::baz; // ok! -} - -mod foo { - pub struct baz; -} - -mod bar { - pub mod baz {} -} -``` -"##, - -E0253: r##" -Attempt was made to import an unimportable value. This can happen when trying -to import a method from a trait. - -Erroneous code example: - -```compile_fail,E0253 -mod foo { - pub trait MyTrait { - fn do_something(); - } -} - -use foo::MyTrait::do_something; -// error: `do_something` is not directly importable - -fn main() {} -``` - -It's invalid to directly import methods belonging to a trait or concrete type. -"##, - -E0254: r##" -Attempt was made to import an item whereas an extern crate with this name has -already been imported. - -Erroneous code example: - -```compile_fail,E0254 -extern crate core; - -mod foo { - pub trait core { - fn do_something(); - } -} - -use foo::core; // error: an extern crate named `core` has already - // been imported in this module - -fn main() {} -``` - -To fix this issue, you have to rename at least one of the two imports. -Example: - -``` -extern crate core as libcore; // ok! - -mod foo { - pub trait core { - fn do_something(); - } -} - -use foo::core; - -fn main() {} -``` -"##, - -E0255: r##" -You can't import a value whose name is the same as another value defined in the -module. - -Erroneous code example: - -```compile_fail,E0255 -use bar::foo; // error: an item named `foo` is already in scope - -fn foo() {} - -mod bar { - pub fn foo() {} -} - -fn main() {} -``` - -You can use aliases in order to fix this error. Example: - -``` -use bar::foo as bar_foo; // ok! - -fn foo() {} - -mod bar { - pub fn foo() {} -} - -fn main() {} -``` - -Or you can reference the item with its parent: - -``` -fn foo() {} - -mod bar { - pub fn foo() {} -} - -fn main() { - bar::foo(); // we get the item by referring to its parent -} -``` -"##, - -E0256: r##" -#### Note: this error code is no longer emitted by the compiler. - -You can't import a type or module when the name of the item being imported is -the same as another type or submodule defined in the module. - -An example of this error: - -```compile_fail -use foo::Bar; // error - -type Bar = u32; - -mod foo { - pub mod Bar { } -} - -fn main() {} -``` -"##, - -E0259: r##" -The name chosen for an external crate conflicts with another external crate -that has been imported into the current module. - -Erroneous code example: - -```compile_fail,E0259 -extern crate core; -extern crate std as core; - -fn main() {} -``` - -The solution is to choose a different name that doesn't conflict with any -external crate imported into the current module. - -Correct example: - -``` -extern crate core; -extern crate std as other_name; - -fn main() {} -``` -"##, - -E0260: r##" -The name for an item declaration conflicts with an external crate's name. - -Erroneous code example: - -```compile_fail,E0260 -extern crate core; - -struct core; - -fn main() {} -``` - -There are two possible solutions: - -Solution #1: Rename the item. - -``` -extern crate core; - -struct xyz; -``` - -Solution #2: Import the crate with a different name. - -``` -extern crate core as xyz; - -struct abc; -``` - -See the Declaration Statements section of the reference for more information -about what constitutes an Item declaration and what does not: - -https://doc.rust-lang.org/reference.html#statements -"##, - -E0364: r##" -Private items cannot be publicly re-exported. This error indicates that you -attempted to `pub use` a type or value that was not itself public. - -Erroneous code example: - -```compile_fail -mod foo { - const X: u32 = 1; -} - -pub use foo::X; - -fn main() {} -``` - -The solution to this problem is to ensure that the items that you are -re-exporting are themselves marked with `pub`: - -``` -mod foo { - pub const X: u32 = 1; -} - -pub use foo::X; - -fn main() {} -``` - -See the 'Use Declarations' section of the reference for more information on -this topic: - -https://doc.rust-lang.org/reference.html#use-declarations -"##, - -E0365: r##" -Private modules cannot be publicly re-exported. This error indicates that you -attempted to `pub use` a module that was not itself public. - -Erroneous code example: - -```compile_fail,E0365 -mod foo { - pub const X: u32 = 1; -} - -pub use foo as foo2; - -fn main() {} -``` - -The solution to this problem is to ensure that the module that you are -re-exporting is itself marked with `pub`: - -``` -pub mod foo { - pub const X: u32 = 1; -} - -pub use foo as foo2; - -fn main() {} -``` - -See the 'Use Declarations' section of the reference for more information -on this topic: - -https://doc.rust-lang.org/reference.html#use-declarations -"##, - -E0401: r##" -Inner items do not inherit type or const parameters from the functions -they are embedded in. - -Erroneous code example: - -```compile_fail,E0401 -fn foo<T>(x: T) { - fn bar(y: T) { // T is defined in the "outer" function - // .. - } - bar(x); -} -``` - -Nor will this: - -```compile_fail,E0401 -fn foo<T>(x: T) { - type MaybeT = Option<T>; - // ... -} -``` - -Or this: - -```compile_fail,E0401 -fn foo<T>(x: T) { - struct Foo { - x: T, - } - // ... -} -``` - -Items inside functions are basically just like top-level items, except -that they can only be used from the function they are in. - -There are a couple of solutions for this. - -If the item is a function, you may use a closure: - -``` -fn foo<T>(x: T) { - let bar = |y: T| { // explicit type annotation may not be necessary - // .. - }; - bar(x); -} -``` - -For a generic item, you can copy over the parameters: - -``` -fn foo<T>(x: T) { - fn bar<T>(y: T) { - // .. - } - bar(x); -} -``` - -``` -fn foo<T>(x: T) { - type MaybeT<T> = Option<T>; -} -``` - -Be sure to copy over any bounds as well: - -``` -fn foo<T: Copy>(x: T) { - fn bar<T: Copy>(y: T) { - // .. - } - bar(x); -} -``` - -``` -fn foo<T: Copy>(x: T) { - struct Foo<T: Copy> { - x: T, - } -} -``` - -This may require additional type hints in the function body. - -In case the item is a function inside an `impl`, defining a private helper -function might be easier: - -``` -# struct Foo<T>(T); -impl<T> Foo<T> { - pub fn foo(&self, x: T) { - self.bar(x); - } - - fn bar(&self, y: T) { - // .. - } -} -``` - -For default impls in traits, the private helper solution won't work, however -closures or copying the parameters should still work. -"##, - -E0403: r##" -Some type parameters have the same name. - -Erroneous code example: - -```compile_fail,E0403 -fn f<T, T>(s: T, u: T) {} // error: the name `T` is already used for a generic - // parameter in this item's generic parameters -``` - -Please verify that none of the type parameters are misspelled, and rename any -clashing parameters. Example: - -``` -fn f<T, Y>(s: T, u: Y) {} // ok! -``` - -Type parameters in an associated item also cannot shadow parameters from the -containing item: - -```compile_fail,E0403 -trait Foo<T> { - fn do_something(&self) -> T; - fn do_something_else<T: Clone>(&self, bar: T); -} -``` -"##, - -E0404: r##" -You tried to use something which is not a trait in a trait position, such as -a bound or `impl`. - -Erroneous code example: - -```compile_fail,E0404 -struct Foo; -struct Bar; - -impl Foo for Bar {} // error: `Foo` is not a trait -``` - -Another erroneous code example: - -```compile_fail,E0404 -struct Foo; - -fn bar<T: Foo>(t: T) {} // error: `Foo` is not a trait -``` - -Please verify that you didn't misspell the trait's name or otherwise use the -wrong identifier. Example: - -``` -trait Foo { - // some functions -} -struct Bar; - -impl Foo for Bar { // ok! - // functions implementation -} -``` - -or - -``` -trait Foo { - // some functions -} - -fn bar<T: Foo>(t: T) {} // ok! -``` - -"##, - -E0405: r##" -The code refers to a trait that is not in scope. - -Erroneous code example: - -```compile_fail,E0405 -struct Foo; - -impl SomeTrait for Foo {} // error: trait `SomeTrait` is not in scope -``` - -Please verify that the name of the trait wasn't misspelled and ensure that it -was imported. Example: - -``` -# #[cfg(for_demonstration_only)] -// solution 1: -use some_file::SomeTrait; - -// solution 2: -trait SomeTrait { - // some functions -} - -struct Foo; - -impl SomeTrait for Foo { // ok! - // implements functions -} -``` -"##, - -E0407: r##" -A definition of a method not in the implemented trait was given in a trait -implementation. - -Erroneous code example: - -```compile_fail,E0407 -trait Foo { - fn a(); -} - -struct Bar; - -impl Foo for Bar { - fn a() {} - fn b() {} // error: method `b` is not a member of trait `Foo` -} -``` - -Please verify you didn't misspell the method name and you used the correct -trait. First example: - -``` -trait Foo { - fn a(); - fn b(); -} - -struct Bar; - -impl Foo for Bar { - fn a() {} - fn b() {} // ok! -} -``` - -Second example: - -``` -trait Foo { - fn a(); -} - -struct Bar; - -impl Foo for Bar { - fn a() {} -} - -impl Bar { - fn b() {} -} -``` -"##, - -E0408: r##" -An "or" pattern was used where the variable bindings are not consistently bound -across patterns. - -Erroneous code example: - -```compile_fail,E0408 -match x { - Some(y) | None => { /* use y */ } // error: variable `y` from pattern #1 is - // not bound in pattern #2 - _ => () -} -``` - -Here, `y` is bound to the contents of the `Some` and can be used within the -block corresponding to the match arm. However, in case `x` is `None`, we have -not specified what `y` is, and the block will use a nonexistent variable. - -To fix this error, either split into multiple match arms: - -``` -let x = Some(1); -match x { - Some(y) => { /* use y */ } - None => { /* ... */ } -} -``` - -or, bind the variable to a field of the same type in all sub-patterns of the -or pattern: - -``` -let x = (0, 2); -match x { - (0, y) | (y, 0) => { /* use y */} - _ => {} -} -``` - -In this example, if `x` matches the pattern `(0, _)`, the second field is set -to `y`. If it matches `(_, 0)`, the first field is set to `y`; so in all -cases `y` is set to some value. -"##, - -E0409: r##" -An "or" pattern was used where the variable bindings are not consistently bound -across patterns. - -Erroneous code example: - -```compile_fail,E0409 -let x = (0, 2); -match x { - (0, ref y) | (y, 0) => { /* use y */} // error: variable `y` is bound with - // different mode in pattern #2 - // than in pattern #1 - _ => () -} -``` - -Here, `y` is bound by-value in one case and by-reference in the other. - -To fix this error, just use the same mode in both cases. -Generally using `ref` or `ref mut` where not already used will fix this: - -``` -let x = (0, 2); -match x { - (0, ref y) | (ref y, 0) => { /* use y */} - _ => () -} -``` - -Alternatively, split the pattern: - -``` -let x = (0, 2); -match x { - (y, 0) => { /* use y */ } - (0, ref y) => { /* use y */} - _ => () -} -``` -"##, - -E0411: r##" -The `Self` keyword was used outside an impl, trait, or type definition. - -Erroneous code example: - -```compile_fail,E0411 -<Self>::foo; // error: use of `Self` outside of an impl, trait, or type - // definition -``` - -The `Self` keyword represents the current type, which explains why it can only -be used inside an impl, trait, or type definition. It gives access to the -associated items of a type: - -``` -trait Foo { - type Bar; -} - -trait Baz : Foo { - fn bar() -> Self::Bar; // like this -} -``` - -However, be careful when two types have a common associated type: - -```compile_fail -trait Foo { - type Bar; -} - -trait Foo2 { - type Bar; -} - -trait Baz : Foo + Foo2 { - fn bar() -> Self::Bar; - // error: ambiguous associated type `Bar` in bounds of `Self` -} -``` - -This problem can be solved by specifying from which trait we want to use the -`Bar` type: - -``` -trait Foo { - type Bar; -} - -trait Foo2 { - type Bar; -} - -trait Baz : Foo + Foo2 { - fn bar() -> <Self as Foo>::Bar; // ok! -} -``` -"##, - -E0412: r##" -The type name used is not in scope. - -Erroneous code examples: - -```compile_fail,E0412 -impl Something {} // error: type name `Something` is not in scope - -// or: - -trait Foo { - fn bar(N); // error: type name `N` is not in scope -} - -// or: - -fn foo(x: T) {} // type name `T` is not in scope -``` - -To fix this error, please verify you didn't misspell the type name, you did -declare it or imported it into the scope. Examples: - -``` -struct Something; - -impl Something {} // ok! - -// or: - -trait Foo { - type N; - - fn bar(_: Self::N); // ok! -} - -// or: - -fn foo<T>(x: T) {} // ok! -``` - -Another case that causes this error is when a type is imported into a parent -module. To fix this, you can follow the suggestion and use File directly or -`use super::File;` which will import the types from the parent namespace. An -example that causes this error is below: - -```compile_fail,E0412 -use std::fs::File; - -mod foo { - fn some_function(f: File) {} -} -``` - -``` -use std::fs::File; - -mod foo { - // either - use super::File; - // or - // use std::fs::File; - fn foo(f: File) {} -} -# fn main() {} // don't insert it for us; that'll break imports -``` -"##, - -E0415: r##" -More than one function parameter have the same name. - -Erroneous code example: - -```compile_fail,E0415 -fn foo(f: i32, f: i32) {} // error: identifier `f` is bound more than - // once in this parameter list -``` - -Please verify you didn't misspell parameters' name. Example: - -``` -fn foo(f: i32, g: i32) {} // ok! -``` -"##, - -E0416: r##" -An identifier is bound more than once in a pattern. - -Erroneous code example: - -```compile_fail,E0416 -match (1, 2) { - (x, x) => {} // error: identifier `x` is bound more than once in the - // same pattern -} -``` - -Please verify you didn't misspell identifiers' name. Example: - -``` -match (1, 2) { - (x, y) => {} // ok! -} -``` - -Or maybe did you mean to unify? Consider using a guard: - -``` -# let (A, B, C) = (1, 2, 3); -match (A, B, C) { - (x, x2, see) if x == x2 => { /* A and B are equal, do one thing */ } - (y, z, see) => { /* A and B unequal; do another thing */ } -} -``` -"##, - -E0422: r##" -You are trying to use an identifier that is either undefined or not a struct. -Erroneous code example: - -```compile_fail,E0422 -fn main () { - let x = Foo { x: 1, y: 2 }; -} -``` - -In this case, `Foo` is undefined, so it inherently isn't anything, and -definitely not a struct. - -```compile_fail -fn main () { - let foo = 1; - let x = foo { x: 1, y: 2 }; -} -``` - -In this case, `foo` is defined, but is not a struct, so Rust can't use it as -one. -"##, - -E0423: r##" -An identifier was used like a function name or a value was expected and the -identifier exists but it belongs to a different namespace. - -For (an erroneous) example, here a `struct` variant name were used as a -function: - -```compile_fail,E0423 -struct Foo { a: bool }; - -let f = Foo(); -// error: expected function, tuple struct or tuple variant, found `Foo` -// `Foo` is a struct name, but this expression uses it like a function name -``` - -Please verify you didn't misspell the name of what you actually wanted to use -here. Example: - -``` -fn Foo() -> u32 { 0 } - -let f = Foo(); // ok! -``` - -It is common to forget the trailing `!` on macro invocations, which would also -yield this error: - -```compile_fail,E0423 -println(""); -// error: expected function, tuple struct or tuple variant, -// found macro `println` -// did you mean `println!(...)`? (notice the trailing `!`) -``` - -Another case where this error is emitted is when a value is expected, but -something else is found: - -```compile_fail,E0423 -pub mod a { - pub const I: i32 = 1; -} - -fn h1() -> i32 { - a.I - //~^ ERROR expected value, found module `a` - // did you mean `a::I`? -} -``` -"##, - -E0424: r##" -The `self` keyword was used inside of an associated function without a "`self` -receiver" parameter. - -Erroneous code example: - -```compile_fail,E0424 -struct Foo; - -impl Foo { - // `bar` is a method, because it has a receiver parameter. - fn bar(&self) {} - - // `foo` is not a method, because it has no receiver parameter. - fn foo() { - self.bar(); // error: `self` value is a keyword only available in - // methods with a `self` parameter - } -} -``` - -The `self` keyword can only be used inside methods, which are associated -functions (functions defined inside of a `trait` or `impl` block) that have a -`self` receiver as its first parameter, like `self`, `&self`, `&mut self` or -`self: &mut Pin<Self>` (this last one is an example of an ["abitrary `self` -type"](https://github.com/rust-lang/rust/issues/44874)). - -Check if the associated function's parameter list should have contained a `self` -receiver for it to be a method, and add it if so. Example: - -``` -struct Foo; - -impl Foo { - fn bar(&self) {} - - fn foo(self) { // `foo` is now a method. - self.bar(); // ok! - } -} -``` -"##, - -E0425: r##" -An unresolved name was used. - -Erroneous code examples: - -```compile_fail,E0425 -something_that_doesnt_exist::foo; -// error: unresolved name `something_that_doesnt_exist::foo` - -// or: - -trait Foo { - fn bar() { - Self; // error: unresolved name `Self` - } -} - -// or: - -let x = unknown_variable; // error: unresolved name `unknown_variable` -``` - -Please verify that the name wasn't misspelled and ensure that the -identifier being referred to is valid for the given situation. Example: - -``` -enum something_that_does_exist { - Foo, -} -``` - -Or: - -``` -mod something_that_does_exist { - pub static foo : i32 = 0i32; -} - -something_that_does_exist::foo; // ok! -``` - -Or: - -``` -let unknown_variable = 12u32; -let x = unknown_variable; // ok! -``` - -If the item is not defined in the current module, it must be imported using a -`use` statement, like so: - -``` -# mod foo { pub fn bar() {} } -# fn main() { -use foo::bar; -bar(); -# } -``` - -If the item you are importing is not defined in some super-module of the -current module, then it must also be declared as public (e.g., `pub fn`). -"##, - -E0426: r##" -An undeclared label was used. - -Erroneous code example: - -```compile_fail,E0426 -loop { - break 'a; // error: use of undeclared label `'a` -} -``` - -Please verify you spelt or declare the label correctly. Example: - -``` -'a: loop { - break 'a; // ok! -} -``` -"##, - -E0428: r##" -A type or module has been defined more than once. - -Erroneous code example: - -```compile_fail,E0428 -struct Bar; -struct Bar; // error: duplicate definition of value `Bar` -``` - -Please verify you didn't misspell the type/module's name or remove/rename the -duplicated one. Example: - -``` -struct Bar; -struct Bar2; // ok! -``` -"##, - -E0429: r##" -The `self` keyword cannot appear alone as the last segment in a `use` -declaration. - -Erroneous code example: - -```compile_fail,E0429 -use std::fmt::self; // error: `self` imports are only allowed within a { } list -``` - -To use a namespace itself in addition to some of its members, `self` may appear -as part of a brace-enclosed list of imports: - -``` -use std::fmt::{self, Debug}; -``` - -If you only want to import the namespace, do so directly: - -``` -use std::fmt; -``` -"##, - -E0430: r##" -The `self` import appears more than once in the list. - -Erroneous code example: - -```compile_fail,E0430 -use something::{self, self}; // error: `self` import can only appear once in - // the list -``` - -Please verify you didn't misspell the import name or remove the duplicated -`self` import. Example: - -``` -# mod something {} -# fn main() { -use something::{self}; // ok! -# } -``` -"##, - -E0431: r##" -An invalid `self` import was made. - -Erroneous code example: - -```compile_fail,E0431 -use {self}; // error: `self` import can only appear in an import list with a - // non-empty prefix -``` - -You cannot import the current module into itself, please remove this import -or verify you didn't misspell it. -"##, - -E0432: r##" -An import was unresolved. - -Erroneous code example: - -```compile_fail,E0432 -use something::Foo; // error: unresolved import `something::Foo`. -``` - -Paths in `use` statements are relative to the crate root. To import items -relative to the current and parent modules, use the `self::` and `super::` -prefixes, respectively. Also verify that you didn't misspell the import -name and that the import exists in the module from where you tried to -import it. Example: - -``` -use self::something::Foo; // ok! - -mod something { - pub struct Foo; -} -# fn main() {} -``` - -Or, if you tried to use a module from an external crate, you may have missed -the `extern crate` declaration (which is usually placed in the crate root): - -``` -extern crate core; // Required to use the `core` crate - -use core::any; -# fn main() {} -``` -"##, - -E0433: r##" -An undeclared type or module was used. - -Erroneous code example: - -```compile_fail,E0433 -let map = HashMap::new(); -// error: failed to resolve: use of undeclared type or module `HashMap` -``` - -Please verify you didn't misspell the type/module's name or that you didn't -forget to import it: - - -``` -use std::collections::HashMap; // HashMap has been imported. -let map: HashMap<u32, u32> = HashMap::new(); // So it can be used! -``` -"##, - -E0434: r##" -This error indicates that a variable usage inside an inner function is invalid -because the variable comes from a dynamic environment. Inner functions do not -have access to their containing environment. - -Erroneous code example: - -```compile_fail,E0434 -fn foo() { - let y = 5; - fn bar() -> u32 { - y // error: can't capture dynamic environment in a fn item; use the - // || { ... } closure form instead. - } -} -``` - -Functions do not capture local variables. To fix this error, you can replace the -function with a closure: - -``` -fn foo() { - let y = 5; - let bar = || { - y - }; -} -``` - -or replace the captured variable with a constant or a static item: - -``` -fn foo() { - static mut X: u32 = 4; - const Y: u32 = 5; - fn bar() -> u32 { - unsafe { - X = 3; - } - Y - } -} -``` -"##, - -E0435: r##" -A non-constant value was used in a constant expression. - -Erroneous code example: - -```compile_fail,E0435 -let foo = 42; -let a: [u8; foo]; // error: attempt to use a non-constant value in a constant -``` - -To fix this error, please replace the value with a constant. Example: - -``` -let a: [u8; 42]; // ok! -``` - -Or: - -``` -const FOO: usize = 42; -let a: [u8; FOO]; // ok! -``` -"##, - -E0437: r##" -Trait implementations can only implement associated types that are members of -the trait in question. This error indicates that you attempted to implement -an associated type whose name does not match the name of any associated type -in the trait. - -Erroneous code example: - -```compile_fail,E0437 -trait Foo {} - -impl Foo for i32 { - type Bar = bool; -} -``` - -The solution to this problem is to remove the extraneous associated type: - -``` -trait Foo {} - -impl Foo for i32 {} -``` -"##, - -E0438: r##" -Trait implementations can only implement associated constants that are -members of the trait in question. This error indicates that you -attempted to implement an associated constant whose name does not -match the name of any associated constant in the trait. - -Erroneous code example: - -```compile_fail,E0438 -trait Foo {} - -impl Foo for i32 { - const BAR: bool = true; -} -``` - -The solution to this problem is to remove the extraneous associated constant: - -``` -trait Foo {} - -impl Foo for i32 {} -``` -"##, - -E0466: r##" -Macro import declarations were malformed. - -Erroneous code examples: - -```compile_fail,E0466 -#[macro_use(a_macro(another_macro))] // error: invalid import declaration -extern crate core as some_crate; - -#[macro_use(i_want = "some_macros")] // error: invalid import declaration -extern crate core as another_crate; -``` - -This is a syntax error at the level of attribute declarations. The proper -syntax for macro imports is the following: - -```ignore (cannot-doctest-multicrate-project) -// In some_crate: -#[macro_export] -macro_rules! get_tacos { - ... -} - -#[macro_export] -macro_rules! get_pimientos { - ... -} - -// In your crate: -#[macro_use(get_tacos, get_pimientos)] // It imports `get_tacos` and -extern crate some_crate; // `get_pimientos` macros from some_crate -``` - -If you would like to import all exported macros, write `macro_use` with no -arguments. -"##, - -E0468: r##" -A non-root module attempts to import macros from another crate. - -Example of erroneous code: - -```compile_fail,E0468 -mod foo { - #[macro_use(debug_assert)] // error: must be at crate root to import - extern crate core; // macros from another crate - fn run_macro() { debug_assert!(true); } -} -``` - -Only `extern crate` imports at the crate root level are allowed to import -macros. - -Either move the macro import to crate root or do without the foreign macros. -This will work: - -``` -#[macro_use(debug_assert)] -extern crate core; - -mod foo { - fn run_macro() { debug_assert!(true); } -} -# fn main() {} -``` -"##, - -E0469: r##" -A macro listed for import was not found. - -Erroneous code example: - -```compile_fail,E0469 -#[macro_use(drink, be_merry)] // error: imported macro not found -extern crate alloc; - -fn main() { - // ... -} -``` - -Either the listed macro is not contained in the imported crate, or it is not -exported from the given crate. - -This could be caused by a typo. Did you misspell the macro's name? - -Double-check the names of the macros listed for import, and that the crate -in question exports them. - -A working version would be: - -```ignore (cannot-doctest-multicrate-project) -// In some_crate crate: -#[macro_export] -macro_rules! eat { - ... -} - -#[macro_export] -macro_rules! drink { - ... -} - -// In your crate: -#[macro_use(eat, drink)] -extern crate some_crate; //ok! -``` -"##, - -E0530: r##" -A binding shadowed something it shouldn't. - -Erroneous code example: - -```compile_fail,E0530 -static TEST: i32 = 0; - -let r: (i32, i32) = (0, 0); -match r { - TEST => {} // error: match bindings cannot shadow statics -} -``` - -To fix this error, just change the binding's name in order to avoid shadowing -one of the following: - -* struct name -* struct/enum variant -* static -* const -* associated const - -Fixed example: - -``` -static TEST: i32 = 0; - -let r: (i32, i32) = (0, 0); -match r { - something => {} // ok! -} -``` -"##, - -E0531: r##" -An unknown tuple struct/variant has been used. - -Erroneous code example: - -```compile_fail,E0531 -let Type(x) = Type(12); // error! -match Bar(12) { - Bar(x) => {} // error! - _ => {} -} -``` - -In most cases, it's either a forgotten import or a typo. However, let's look at -how you can have such a type: - -```edition2018 -struct Type(u32); // this is a tuple struct - -enum Foo { - Bar(u32), // this is a tuple variant -} - -use Foo::*; // To use Foo's variant directly, we need to import them in - // the scope. -``` - -Either way, it should work fine with our previous code: - -```edition2018 -struct Type(u32); - -enum Foo { - Bar(u32), -} -use Foo::*; - -let Type(x) = Type(12); // ok! -match Type(12) { - Type(x) => {} // ok! - _ => {} -} -``` -"##, - -E0532: r##" -Pattern arm did not match expected kind. - -Erroneous code example: - -```compile_fail,E0532 -enum State { - Succeeded, - Failed(String), -} - -fn print_on_failure(state: &State) { - match *state { - // error: expected unit struct, unit variant or constant, found tuple - // variant `State::Failed` - State::Failed => println!("Failed"), - _ => () - } -} -``` - -To fix this error, ensure the match arm kind is the same as the expression -matched. - -Fixed example: - -``` -enum State { - Succeeded, - Failed(String), -} - -fn print_on_failure(state: &State) { - match *state { - State::Failed(ref msg) => println!("Failed with {}", msg), - _ => () - } -} -``` -"##, - -E0573: r##" -Something other than a type has been used when one was expected. - -Erroneous code examples: - -```compile_fail,E0573 -enum Dragon { - Born, -} - -fn oblivion() -> Dragon::Born { // error! - Dragon::Born -} - -const HOBBIT: u32 = 2; -impl HOBBIT {} // error! - -enum Wizard { - Gandalf, - Saruman, -} - -trait Isengard { - fn wizard(_: Wizard::Saruman); // error! -} -``` - -In all these errors, a type was expected. For example, in the first error, if -we want to return the `Born` variant from the `Dragon` enum, we must set the -function to return the enum and not its variant: - -``` -enum Dragon { - Born, -} - -fn oblivion() -> Dragon { // ok! - Dragon::Born -} -``` - -In the second error, you can't implement something on an item, only on types. -We would need to create a new type if we wanted to do something similar: - -``` -struct Hobbit(u32); // we create a new type - -const HOBBIT: Hobbit = Hobbit(2); -impl Hobbit {} // ok! -``` - -In the third case, we tried to only expect one variant of the `Wizard` enum, -which is not possible. To make this work, we need to using pattern matching -over the `Wizard` enum: - -``` -enum Wizard { - Gandalf, - Saruman, -} - -trait Isengard { - fn wizard(w: Wizard) { // ok! - match w { - Wizard::Saruman => { - // do something - } - _ => {} // ignore everything else - } - } -} -``` -"##, - -E0574: r##" -Something other than a struct, variant or union has been used when one was -expected. - -Erroneous code example: - -```compile_fail,E0574 -mod Mordor {} - -let sauron = Mordor { x: () }; // error! - -enum Jak { - Daxter { i: isize }, -} - -let eco = Jak::Daxter { i: 1 }; -match eco { - Jak { i } => {} // error! -} -``` - -In all these errors, a type was expected. For example, in the first error, -we tried to instantiate the `Mordor` module, which is impossible. If you want -to instantiate a type inside a module, you can do it as follow: - -``` -mod Mordor { - pub struct TheRing { - pub x: usize, - } -} - -let sauron = Mordor::TheRing { x: 1 }; // ok! -``` - -In the second error, we tried to bind the `Jak` enum directly, which is not -possible: you can only bind one of its variants. To do so: - -``` -enum Jak { - Daxter { i: isize }, -} - -let eco = Jak::Daxter { i: 1 }; -match eco { - Jak::Daxter { i } => {} // ok! -} -``` -"##, - -E0575: r##" -Something other than a type or an associated type was given. - -Erroneous code example: - -```compile_fail,E0575 -enum Rick { Morty } - -let _: <u8 as Rick>::Morty; // error! - -trait Age { - type Empire; - fn Mythology() {} -} - -impl Age for u8 { - type Empire = u16; -} - -let _: <u8 as Age>::Mythology; // error! -``` - -In both cases, we're declaring a variable (called `_`) and we're giving it a -type. However, `<u8 as Rick>::Morty` and `<u8 as Age>::Mythology` aren't types, -therefore the compiler throws an error. - -`<u8 as Rick>::Morty` is an enum variant, you cannot use a variant as a type, -you have to use the enum directly: - -``` -enum Rick { Morty } - -let _: Rick; // ok! -``` - -`<u8 as Age>::Mythology` is a trait method, which is definitely not a type. -However, the `Age` trait provides an associated type `Empire` which can be -used as a type: - -``` -trait Age { - type Empire; - fn Mythology() {} -} - -impl Age for u8 { - type Empire = u16; -} - -let _: <u8 as Age>::Empire; // ok! -``` -"##, - -E0576: r##" -An associated item wasn't found in the given type. - -Erroneous code example: - -```compile_fail,E0576 -trait Hello { - type Who; - - fn hello() -> <Self as Hello>::You; // error! -} -``` - -In this example, we tried to use the non-existent associated type `You` of the -`Hello` trait. To fix this error, use an existing associated type: - -``` -trait Hello { - type Who; - - fn hello() -> <Self as Hello>::Who; // ok! -} -``` -"##, - -E0577: r##" -Something other than a module was found in visibility scope. - -Erroneous code example: - -```compile_fail,E0577,edition2018 -pub struct Sea; - -pub (in crate::Sea) struct Shark; // error! - -fn main() {} -``` - -`Sea` is not a module, therefore it is invalid to use it in a visibility path. -To fix this error we need to ensure `Sea` is a module. - -Please note that the visibility scope can only be applied on ancestors! - -```edition2018 -pub mod Sea { - pub (in crate::Sea) struct Shark; // ok! -} - -fn main() {} -``` -"##, - -E0578: r##" -A module cannot be found and therefore, the visibility cannot be determined. - -Erroneous code example: - -```compile_fail,E0578,edition2018 -foo!(); - -pub (in ::Sea) struct Shark; // error! - -fn main() {} -``` - -Because of the call to the `foo` macro, the compiler guesses that the missing -module could be inside it and fails because the macro definition cannot be -found. - -To fix this error, please be sure that the module is in scope: - -```edition2018 -pub mod Sea { - pub (in crate::Sea) struct Shark; -} - -fn main() {} -``` -"##, - -E0603: r##" -A private item was used outside its scope. - -Erroneous code example: - -```compile_fail,E0603 -mod SomeModule { - const PRIVATE: u32 = 0x_a_bad_1dea_u32; // This const is private, so we - // can't use it outside of the - // `SomeModule` module. -} - -println!("const value: {}", SomeModule::PRIVATE); // error: constant `PRIVATE` - // is private -``` - -In order to fix this error, you need to make the item public by using the `pub` -keyword. Example: - -``` -mod SomeModule { - pub const PRIVATE: u32 = 0x_a_bad_1dea_u32; // We set it public by using the - // `pub` keyword. -} - -println!("const value: {}", SomeModule::PRIVATE); // ok! -``` -"##, - -E0659: r##" -An item usage is ambiguous. - -Erroneous code example: - -```compile_fail,edition2018,E0659 -pub mod moon { - pub fn foo() {} -} - -pub mod earth { - pub fn foo() {} -} - -mod collider { - pub use crate::moon::*; - pub use crate::earth::*; -} - -fn main() { - crate::collider::foo(); // ERROR: `foo` is ambiguous -} -``` - -This error generally appears when two items with the same name are imported into -a module. Here, the `foo` functions are imported and reexported from the -`collider` module and therefore, when we're using `collider::foo()`, both -functions collide. - -To solve this error, the best solution is generally to keep the path before the -item when using it. Example: - -```edition2018 -pub mod moon { - pub fn foo() {} -} - -pub mod earth { - pub fn foo() {} -} - -mod collider { - pub use crate::moon; - pub use crate::earth; -} - -fn main() { - crate::collider::moon::foo(); // ok! - crate::collider::earth::foo(); // ok! -} -``` -"##, - -E0671: r##" -#### Note: this error code is no longer emitted by the compiler. - -Const parameters cannot depend on type parameters. -The following is therefore invalid: - -```compile_fail,E0741 -#![feature(const_generics)] - -fn const_id<T, const N: T>() -> T { // error - N -} -``` -"##, - -E0735: r##" -Type parameter defaults cannot use `Self` on structs, enums, or unions. - -Erroneous code example: - -```compile_fail,E0735 -struct Foo<X = Box<Self>> { - field1: Option<X>, - field2: Option<X>, -} -// error: type parameters cannot use `Self` in their defaults. -``` -"##, - -E0742: r##" -Visibility is restricted to a module which isn't an ancestor of the current -item. - -Erroneous code example: - -```compile_fail,E0742,edition2018 -pub mod Sea {} - -pub (in crate::Sea) struct Shark; // error! - -fn main() {} -``` - -To fix this error, we need to move the `Shark` struct inside the `Sea` module: - -```edition2018 -pub mod Sea { - pub (in crate::Sea) struct Shark; // ok! -} - -fn main() {} -``` - -Of course, you can do it as long as the module you're referring to is an -ancestor: - -```edition2018 -pub mod Earth { - pub mod Sea { - pub (in crate::Earth) struct Shark; // ok! - } -} - -fn main() {} -``` -"##, - -; -// E0153, unused error code -// E0157, unused error code -// E0257, -// E0258, -// E0402, // cannot use an outer type parameter in this context -// E0406, merged into 420 -// E0410, merged into 408 -// E0413, merged into 530 -// E0414, merged into 530 -// E0417, merged into 532 -// E0418, merged into 532 -// E0419, merged into 531 -// E0420, merged into 532 -// E0421, merged into 531 -// E0427, merged into 530 -// E0467, removed -// E0470, removed -} diff --git a/src/librustc_resolve/late.rs b/src/librustc_resolve/late.rs index 3340566a875..24d6331bbd3 100644 --- a/src/librustc_resolve/late.rs +++ b/src/librustc_resolve/late.rs @@ -30,6 +30,8 @@ use syntax_pos::Span; use std::collections::BTreeSet; use std::mem::replace; +use rustc_error_codes::*; + mod diagnostics; type Res = def::Res<NodeId>; diff --git a/src/librustc_resolve/late/diagnostics.rs b/src/librustc_resolve/late/diagnostics.rs index 0b9997386c8..3be033697d2 100644 --- a/src/librustc_resolve/late/diagnostics.rs +++ b/src/librustc_resolve/late/diagnostics.rs @@ -18,6 +18,8 @@ use syntax::util::lev_distance::find_best_match_for_name; use syntax_pos::hygiene::MacroKind; use syntax_pos::Span; +use rustc_error_codes::*; + type Res = def::Res<ast::NodeId>; /// A field or associated item from self type suggested in case of resolution failure. diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 88c675a6ce5..47e8cf80a05 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -64,9 +64,10 @@ use late::{HasGenericParams, PathSource, Rib, RibKind::*}; use resolve_imports::{ImportDirective, ImportDirectiveSubclass, NameResolution, ImportResolver}; use macros::{LegacyBinding, LegacyScope}; +use rustc_error_codes::*; + type Res = def::Res<NodeId>; -pub mod error_codes; mod diagnostics; mod late; mod macros; diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs index 083b11daaa1..5c8e7909631 100644 --- a/src/librustc_resolve/resolve_imports.rs +++ b/src/librustc_resolve/resolve_imports.rs @@ -30,6 +30,8 @@ use syntax::{struct_span_err, unwrap_or}; use syntax_pos::hygiene::ExpnId; use syntax_pos::{MultiSpan, Span}; +use rustc_error_codes::*; + use log::*; use std::cell::Cell; diff --git a/src/librustc_typeck/Cargo.toml b/src/librustc_typeck/Cargo.toml index 60a7a2f4598..a78eba7c0b7 100644 --- a/src/librustc_typeck/Cargo.toml +++ b/src/librustc_typeck/Cargo.toml @@ -21,3 +21,4 @@ smallvec = { version = "1.0", features = ["union", "may_dangle"] } syntax = { path = "../libsyntax" } syntax_pos = { path = "../libsyntax_pos" } rustc_index = { path = "../librustc_index" } +rustc_error_codes = { path = "../librustc_error_codes" } diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index ee3ebd691e4..c3bd916b9ce 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -36,6 +36,8 @@ use std::slice; use rustc_data_structures::fx::FxHashSet; +use rustc_error_codes::*; + #[derive(Debug)] pub struct PathSeg(pub DefId, pub usize); diff --git a/src/librustc_typeck/check/autoderef.rs b/src/librustc_typeck/check/autoderef.rs index ab5cabcaa4f..20c54e8f698 100644 --- a/src/librustc_typeck/check/autoderef.rs +++ b/src/librustc_typeck/check/autoderef.rs @@ -12,6 +12,8 @@ use rustc::ty::adjustment::{Adjustment, Adjust, OverloadedDeref}; use syntax_pos::Span; use syntax::ast::Ident; +use rustc_error_codes::*; + use std::iter; #[derive(Copy, Clone, Debug)] diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs index c195e91a52b..1b3af48ea83 100644 --- a/src/librustc_typeck/check/callee.rs +++ b/src/librustc_typeck/check/callee.rs @@ -16,6 +16,8 @@ use syntax_pos::Span; use rustc::hir; +use rustc_error_codes::*; + /// Checks that it is legal to call methods of the trait corresponding /// to `trait_id` (this only cares about the trait, not the specific /// method that is called). diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs index 3245f2cca79..035ece23810 100644 --- a/src/librustc_typeck/check/cast.rs +++ b/src/librustc_typeck/check/cast.rs @@ -46,6 +46,8 @@ use syntax::ast; use syntax_pos::Span; use crate::util::common::ErrorReported; +use rustc_error_codes::*; + /// Reifies a cast check to be checked once we have full type information for /// a function context. pub struct CastCheck<'tcx> { diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index a105755ca9a..871acb2726a 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -73,6 +73,8 @@ use syntax::symbol::sym; use syntax_pos; use rustc_target::spec::abi::Abi; +use rustc_error_codes::*; + struct Coerce<'a, 'tcx> { fcx: &'a FnCtxt<'a, 'tcx>, cause: ObligationCause<'tcx>, diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs index 2f0b1c358f0..42414228522 100644 --- a/src/librustc_typeck/check/compare_method.rs +++ b/src/librustc_typeck/check/compare_method.rs @@ -14,6 +14,8 @@ use syntax::errors::pluralize; use super::{Inherited, FnCtxt, potentially_plural_count}; +use rustc_error_codes::*; + /// Checks that a method from an impl conforms to the signature of /// the same method as declared in the trait. /// diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index 0c8df9bad44..fba933ab0ce 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -12,6 +12,8 @@ use crate::util::common::ErrorReported; use syntax_pos::Span; +use rustc_error_codes::*; + /// This function confirms that the `Drop` implementation identified by /// `drop_impl_did` is not any more specialized than the type it is /// attached to (Issue #8142). diff --git a/src/librustc_typeck/check/expr.rs b/src/librustc_typeck/check/expr.rs index cfe36b57c2d..0ba56ba5b3a 100644 --- a/src/librustc_typeck/check/expr.rs +++ b/src/librustc_typeck/check/expr.rs @@ -42,6 +42,8 @@ use rustc::ty::TypeFoldable; use rustc::ty::subst::InternalSubsts; use rustc::traits::{self, ObligationCauseCode}; +use rustc_error_codes::*; + use std::fmt::Display; impl<'a, 'tcx> FnCtxt<'a, 'tcx> { diff --git a/src/librustc_typeck/check/intrinsic.rs b/src/librustc_typeck/check/intrinsic.rs index 84a15c6e4eb..9f034e65b6e 100644 --- a/src/librustc_typeck/check/intrinsic.rs +++ b/src/librustc_typeck/check/intrinsic.rs @@ -12,6 +12,8 @@ use syntax::symbol::Symbol; use rustc::hir; +use rustc_error_codes::*; + use std::iter; fn equate_intrinsic_type<'tcx>( diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 7ea7dba5a28..9717190045a 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -35,6 +35,8 @@ use std::mem; use std::ops::Deref; use std::cmp::max; +use rustc_error_codes::*; + use smallvec::{smallvec, SmallVec}; use self::CandidateKind::*; diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index 0b1657c4494..6e37a1a47f0 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -18,6 +18,8 @@ use syntax_pos::{Span, FileName}; use syntax::ast; use syntax::util::lev_distance; +use rustc_error_codes::*; + use std::cmp::Ordering; use super::{MethodError, NoMatchData, CandidateSource}; diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 2363dbc5303..41c8fc02662 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -130,6 +130,8 @@ use syntax::source_map::{DUMMY_SP, original_sp}; use syntax::symbol::{kw, sym, Ident}; use syntax::util::parser::ExprPrecedence; +use rustc_error_codes::*; + use std::cell::{Cell, RefCell, Ref, RefMut}; use std::collections::hash_map::Entry; use std::cmp; diff --git a/src/librustc_typeck/check/op.rs b/src/librustc_typeck/check/op.rs index 81a31597905..28db09fe92b 100644 --- a/src/librustc_typeck/check/op.rs +++ b/src/librustc_typeck/check/op.rs @@ -11,6 +11,8 @@ use syntax_pos::Span; use syntax::ast::Ident; use rustc::hir; +use rustc_error_codes::*; + impl<'a, 'tcx> FnCtxt<'a, 'tcx> { /// Checks a `a <op>= b` pub fn check_binop_assign( diff --git a/src/librustc_typeck/check/pat.rs b/src/librustc_typeck/check/pat.rs index 9421dbc2b2c..b2250559506 100644 --- a/src/librustc_typeck/check/pat.rs +++ b/src/librustc_typeck/check/pat.rs @@ -14,6 +14,8 @@ use syntax::util::lev_distance::find_best_match_for_name; use syntax_pos::Span; use syntax_pos::hygiene::DesugaringKind; +use rustc_error_codes::*; + use std::collections::hash_map::Entry::{Occupied, Vacant}; use std::cmp; diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index fd97493b591..6508295b8ed 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -13,11 +13,13 @@ use syntax::ast; use syntax::feature_gate::{self, GateIssue}; use syntax_pos::Span; use syntax::symbol::sym; -use errors::{DiagnosticBuilder, DiagnosticId}; +use errors::DiagnosticBuilder; use rustc::hir::itemlikevisit::ParItemLikeVisitor; use rustc::hir; +use rustc_error_codes::*; + /// Helper type of a temporary returned by `.for_item(...)`. /// This is necessary because we can't write the following bound: /// @@ -845,12 +847,13 @@ fn check_method_receiver<'fcx, 'tcx>( } fn e0307(fcx: &FnCtxt<'fcx, 'tcx>, span: Span, receiver_ty: Ty<'_>) { - fcx.tcx.sess.diagnostic().struct_span_err( + struct_span_err!( + fcx.tcx.sess.diagnostic(), span, - &format!("invalid `self` parameter type: {:?}", receiver_ty) + E0307, + "invalid `self` parameter type: {:?}", receiver_ty, ).note("type of `self` must be `Self` or a type that dereferences to it") .help(HELP_FOR_SELF_TYPE) - .code(DiagnosticId::Error("E0307".into())) .emit(); } diff --git a/src/librustc_typeck/coherence/builtin.rs b/src/librustc_typeck/coherence/builtin.rs index d613abc4352..d126a96014b 100644 --- a/src/librustc_typeck/coherence/builtin.rs +++ b/src/librustc_typeck/coherence/builtin.rs @@ -17,6 +17,8 @@ use rustc::hir::def_id::DefId; use hir::Node; use rustc::hir::{self, ItemKind}; +use rustc_error_codes::*; + pub fn check_trait(tcx: TyCtxt<'_>, trait_def_id: DefId) { Checker { tcx, trait_def_id } .check(tcx.lang_items().drop_trait(), visit_implementation_of_drop) diff --git a/src/librustc_typeck/coherence/inherent_impls.rs b/src/librustc_typeck/coherence/inherent_impls.rs index 5daa8f5d319..1c228396b8c 100644 --- a/src/librustc_typeck/coherence/inherent_impls.rs +++ b/src/librustc_typeck/coherence/inherent_impls.rs @@ -15,6 +15,8 @@ use rustc::ty::{self, CrateInherentImpls, TyCtxt}; use syntax::ast; use syntax_pos::Span; +use rustc_error_codes::*; + /// On-demand query: yields a map containing all types mapped to their inherent impls. pub fn crate_inherent_impls( tcx: TyCtxt<'_>, diff --git a/src/librustc_typeck/coherence/inherent_impls_overlap.rs b/src/librustc_typeck/coherence/inherent_impls_overlap.rs index 0aae8fbe131..39ecfad89bc 100644 --- a/src/librustc_typeck/coherence/inherent_impls_overlap.rs +++ b/src/librustc_typeck/coherence/inherent_impls_overlap.rs @@ -5,6 +5,8 @@ use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::traits::{self, IntercrateMode}; use rustc::ty::TyCtxt; +use rustc_error_codes::*; + pub fn crate_inherent_impls_overlap_check(tcx: TyCtxt<'_>, crate_num: CrateNum) { assert_eq!(crate_num, LOCAL_CRATE); let krate = tcx.hir().krate(); diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 8adf4bb94a8..eac8958bc3b 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -12,6 +12,8 @@ use rustc::ty::{self, TyCtxt, TypeFoldable}; use rustc::ty::query::Providers; use rustc::util::common::time; +use rustc_error_codes::*; + mod builtin; mod inherent_impls; mod inherent_impls_overlap; diff --git a/src/librustc_typeck/coherence/orphan.rs b/src/librustc_typeck/coherence/orphan.rs index 88fa09cc936..c5d9ef2030c 100644 --- a/src/librustc_typeck/coherence/orphan.rs +++ b/src/librustc_typeck/coherence/orphan.rs @@ -6,6 +6,8 @@ use rustc::ty::{self, TyCtxt}; use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::hir; +use rustc_error_codes::*; + pub fn check(tcx: TyCtxt<'_>) { let mut orphan = OrphanChecker { tcx }; tcx.hir().krate().visit_all_item_likes(&mut orphan); diff --git a/src/librustc_typeck/coherence/unsafety.rs b/src/librustc_typeck/coherence/unsafety.rs index b7cc6feee44..5bb44499968 100644 --- a/src/librustc_typeck/coherence/unsafety.rs +++ b/src/librustc_typeck/coherence/unsafety.rs @@ -5,6 +5,8 @@ use rustc::ty::TyCtxt; use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::hir::{self, Unsafety}; +use rustc_error_codes::*; + pub fn check(tcx: TyCtxt<'_>) { let mut unsafety = UnsafetyChecker { tcx }; tcx.hir().krate().visit_all_item_likes(&mut unsafety); diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 9c1da65c846..d9f6d79f218 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -46,7 +46,9 @@ use rustc::hir::intravisit::{self, NestedVisitorMap, Visitor}; use rustc::hir::GenericParamKind; use rustc::hir::{self, CodegenFnAttrFlags, CodegenFnAttrs, Unsafety}; -use errors::{Applicability, DiagnosticId, StashKey}; +use errors::{Applicability, StashKey}; + +use rustc_error_codes::*; struct OnlySelfBounds(bool); @@ -158,10 +160,11 @@ impl Visitor<'tcx> for CollectItemTypesVisitor<'tcx> { // Utility types and common code for the above passes. fn bad_placeholder_type(tcx: TyCtxt<'tcx>, span: Span) -> errors::DiagnosticBuilder<'tcx> { - let mut diag = tcx.sess.struct_span_err_with_code( + let mut diag = struct_span_err!( + tcx.sess, span, + E0121, "the type placeholder `_` is not allowed within types on item signatures", - DiagnosticId::Error("E0121".into()), ); diag.span_label(span, "not allowed in type signatures"); diag diff --git a/src/librustc_typeck/error_codes.rs b/src/librustc_typeck/error_codes.rs deleted file mode 100644 index 02783f65df5..00000000000 --- a/src/librustc_typeck/error_codes.rs +++ /dev/null @@ -1,5149 +0,0 @@ -// ignore-tidy-filelength - -syntax::register_diagnostics! { - -E0023: r##" -A pattern attempted to extract an incorrect number of fields from a variant. - -Erroneous code example: - -``` -enum Fruit { - Apple(String, String), - Pear(u32), -} -``` - -A pattern used to match against an enum variant must provide a sub-pattern for -each field of the enum variant. - -Here the `Apple` variant has two fields, and should be matched against like so: - -``` -enum Fruit { - Apple(String, String), - Pear(u32), -} - -let x = Fruit::Apple(String::new(), String::new()); - -// Correct. -match x { - Fruit::Apple(a, b) => {}, - _ => {} -} -``` - -Matching with the wrong number of fields has no sensible interpretation: - -```compile_fail,E0023 -enum Fruit { - Apple(String, String), - Pear(u32), -} - -let x = Fruit::Apple(String::new(), String::new()); - -// Incorrect. -match x { - Fruit::Apple(a) => {}, - Fruit::Apple(a, b, c) => {}, -} -``` - -Check how many fields the enum was declared with and ensure that your pattern -uses the same number. -"##, - -E0025: r##" -Each field of a struct can only be bound once in a pattern. - -Erroneous code example: - -```compile_fail,E0025 -struct Foo { - a: u8, - b: u8, -} - -fn main(){ - let x = Foo { a:1, b:2 }; - - let Foo { a: x, a: y } = x; - // error: field `a` bound multiple times in the pattern -} -``` - -Each occurrence of a field name binds the value of that field, so to fix this -error you will have to remove or alter the duplicate uses of the field name. -Perhaps you misspelled another field name? Example: - -``` -struct Foo { - a: u8, - b: u8, -} - -fn main(){ - let x = Foo { a:1, b:2 }; - - let Foo { a: x, b: y } = x; // ok! -} -``` -"##, - -E0026: r##" -A struct pattern attempted to extract a non-existent field from a struct. - -Erroneous code example: - -```compile_fail,E0026 -struct Thing { - x: u32, - y: u32, -} - -let thing = Thing { x: 0, y: 0 }; - -match thing { - Thing { x, z } => {} // error: `Thing::z` field doesn't exist -} -``` - -If you are using shorthand field patterns but want to refer to the struct field -by a different name, you should rename it explicitly. Struct fields are -identified by the name used before the colon `:` so struct patterns should -resemble the declaration of the struct type being matched. - -``` -struct Thing { - x: u32, - y: u32, -} - -let thing = Thing { x: 0, y: 0 }; - -match thing { - Thing { x, y: z } => {} // we renamed `y` to `z` -} -``` -"##, - -E0027: r##" -A pattern for a struct fails to specify a sub-pattern for every one of the -struct's fields. - -Erroneous code example: - -```compile_fail,E0027 -struct Dog { - name: String, - age: u32, -} - -let d = Dog { name: "Rusty".to_string(), age: 8 }; - -// This is incorrect. -match d { - Dog { age: x } => {} -} -``` - -To fix this error, ensure that each field from the struct's definition is -mentioned in the pattern, or use `..` to ignore unwanted fields. Example: - -``` -struct Dog { - name: String, - age: u32, -} - -let d = Dog { name: "Rusty".to_string(), age: 8 }; - -match d { - Dog { name: ref n, age: x } => {} -} - -// This is also correct (ignore unused fields). -match d { - Dog { age: x, .. } => {} -} -``` -"##, - -E0029: r##" -Something other than numbers and characters has been used for a range. - -Erroneous code example: - -```compile_fail,E0029 -let string = "salutations !"; - -// The ordering relation for strings cannot be evaluated at compile time, -// so this doesn't work: -match string { - "hello" ..= "world" => {} - _ => {} -} - -// This is a more general version, using a guard: -match string { - s if s >= "hello" && s <= "world" => {} - _ => {} -} -``` - -In a match expression, only numbers and characters can be matched against a -range. This is because the compiler checks that the range is non-empty at -compile-time, and is unable to evaluate arbitrary comparison functions. If you -want to capture values of an orderable type between two end-points, you can use -a guard. -"##, - -E0033: r##" -A trait type has been dereferenced. - -Erroneous code example: - -```compile_fail,E0033 -# trait SomeTrait { fn method_one(&self){} fn method_two(&self){} } -# impl<T> SomeTrait for T {} -let trait_obj: &SomeTrait = &"some_value"; - -// This tries to implicitly dereference to create an unsized local variable. -let &invalid = trait_obj; - -// You can call methods without binding to the value being pointed at. -trait_obj.method_one(); -trait_obj.method_two(); -``` - -A pointer to a trait type cannot be implicitly dereferenced by a pattern. Every -trait defines a type, but because the size of trait implementers isn't fixed, -this type has no compile-time size. Therefore, all accesses to trait types must -be through pointers. If you encounter this error you should try to avoid -dereferencing the pointer. - -You can read more about trait objects in the [Trait Objects] section of the -Reference. - -[Trait Objects]: https://doc.rust-lang.org/reference/types.html#trait-objects -"##, - -E0034: r##" -The compiler doesn't know what method to call because more than one method -has the same prototype. - -Erroneous code example: - -```compile_fail,E0034 -struct Test; - -trait Trait1 { - fn foo(); -} - -trait Trait2 { - fn foo(); -} - -impl Trait1 for Test { fn foo() {} } -impl Trait2 for Test { fn foo() {} } - -fn main() { - Test::foo() // error, which foo() to call? -} -``` - -To avoid this error, you have to keep only one of them and remove the others. -So let's take our example and fix it: - -``` -struct Test; - -trait Trait1 { - fn foo(); -} - -impl Trait1 for Test { fn foo() {} } - -fn main() { - Test::foo() // and now that's good! -} -``` - -However, a better solution would be using fully explicit naming of type and -trait: - -``` -struct Test; - -trait Trait1 { - fn foo(); -} - -trait Trait2 { - fn foo(); -} - -impl Trait1 for Test { fn foo() {} } -impl Trait2 for Test { fn foo() {} } - -fn main() { - <Test as Trait1>::foo() -} -``` - -One last example: - -``` -trait F { - fn m(&self); -} - -trait G { - fn m(&self); -} - -struct X; - -impl F for X { fn m(&self) { println!("I am F"); } } -impl G for X { fn m(&self) { println!("I am G"); } } - -fn main() { - let f = X; - - F::m(&f); // it displays "I am F" - G::m(&f); // it displays "I am G" -} -``` -"##, - -E0040: r##" -It is not allowed to manually call destructors in Rust. - -Erroneous code example: - -```compile_fail,E0040 -struct Foo { - x: i32, -} - -impl Drop for Foo { - fn drop(&mut self) { - println!("kaboom"); - } -} - -fn main() { - let mut x = Foo { x: -7 }; - x.drop(); // error: explicit use of destructor method -} -``` - -It is unnecessary to do this since `drop` is called automatically whenever a -value goes out of scope. However, if you really need to drop a value by hand, -you can use the `std::mem::drop` function: - -``` -struct Foo { - x: i32, -} - -impl Drop for Foo { - fn drop(&mut self) { - println!("kaboom"); - } -} - -fn main() { - let mut x = Foo { x: -7 }; - drop(x); // ok! -} -``` -"##, - -E0044: r##" -You cannot use type or const parameters on foreign items. - -Erroneous code example: - -```compile_fail,E0044 -extern { fn some_func<T>(x: T); } -``` - -To fix this, replace the generic parameter with the specializations that you -need: - -``` -extern { fn some_func_i32(x: i32); } -extern { fn some_func_i64(x: i64); } -``` -"##, - -E0045: r##" -Variadic parameters have been used on a non-C ABI function. - -Erroneous code example: - -```compile_fail,E0045 -#![feature(unboxed_closures)] - -extern "rust-call" { - fn foo(x: u8, ...); // error! -} -``` - -Rust only supports variadic parameters for interoperability with C code in its -FFI. As such, variadic parameters can only be used with functions which are -using the C ABI. To fix such code, put them in an extern "C" block: - -``` -extern "C" { - fn foo (x: u8, ...); -} -``` -"##, - -E0046: r##" -Items are missing in a trait implementation. - -Erroneous code example: - -```compile_fail,E0046 -trait Foo { - fn foo(); -} - -struct Bar; - -impl Foo for Bar {} -// error: not all trait items implemented, missing: `foo` -``` - -When trying to make some type implement a trait `Foo`, you must, at minimum, -provide implementations for all of `Foo`'s required methods (meaning the -methods that do not have default implementations), as well as any required -trait items like associated types or constants. Example: - -``` -trait Foo { - fn foo(); -} - -struct Bar; - -impl Foo for Bar { - fn foo() {} // ok! -} -``` -"##, - -E0049: r##" -An attempted implementation of a trait method has the wrong number of type or -const parameters. - -Erroneous code example: - -```compile_fail,E0049 -trait Foo { - fn foo<T: Default>(x: T) -> Self; -} - -struct Bar; - -// error: method `foo` has 0 type parameters but its trait declaration has 1 -// type parameter -impl Foo for Bar { - fn foo(x: bool) -> Self { Bar } -} -``` - -For example, the `Foo` trait has a method `foo` with a type parameter `T`, -but the implementation of `foo` for the type `Bar` is missing this parameter. -To fix this error, they must have the same type parameters: - -``` -trait Foo { - fn foo<T: Default>(x: T) -> Self; -} - -struct Bar; - -impl Foo for Bar { - fn foo<T: Default>(x: T) -> Self { // ok! - Bar - } -} -``` -"##, - -E0050: r##" -An attempted implementation of a trait method has the wrong number of function -parameters. - -Erroneous code example: - -```compile_fail,E0050 -trait Foo { - fn foo(&self, x: u8) -> bool; -} - -struct Bar; - -// error: method `foo` has 1 parameter but the declaration in trait `Foo::foo` -// has 2 -impl Foo for Bar { - fn foo(&self) -> bool { true } -} -``` - -For example, the `Foo` trait has a method `foo` with two function parameters -(`&self` and `u8`), but the implementation of `foo` for the type `Bar` omits -the `u8` parameter. To fix this error, they must have the same parameters: - -``` -trait Foo { - fn foo(&self, x: u8) -> bool; -} - -struct Bar; - -impl Foo for Bar { - fn foo(&self, x: u8) -> bool { // ok! - true - } -} -``` -"##, - -E0053: r##" -The parameters of any trait method must match between a trait implementation -and the trait definition. - -Erroneous code example: - -```compile_fail,E0053 -trait Foo { - fn foo(x: u16); - fn bar(&self); -} - -struct Bar; - -impl Foo for Bar { - // error, expected u16, found i16 - fn foo(x: i16) { } - - // error, types differ in mutability - fn bar(&mut self) { } -} -``` -"##, - -E0054: r##" -It is not allowed to cast to a bool. - -Erroneous code example: - -```compile_fail,E0054 -let x = 5; - -// Not allowed, won't compile -let x_is_nonzero = x as bool; -``` - -If you are trying to cast a numeric type to a bool, you can compare it with -zero instead: - -``` -let x = 5; - -// Ok -let x_is_nonzero = x != 0; -``` -"##, - -E0055: r##" -During a method call, a value is automatically dereferenced as many times as -needed to make the value's type match the method's receiver. The catch is that -the compiler will only attempt to dereference a number of times up to the -recursion limit (which can be set via the `recursion_limit` attribute). - -For a somewhat artificial example: - -```compile_fail,E0055 -#![recursion_limit="5"] - -struct Foo; - -impl Foo { - fn foo(&self) {} -} - -fn main() { - let foo = Foo; - let ref_foo = &&&&&Foo; - - // error, reached the recursion limit while auto-dereferencing `&&&&&Foo` - ref_foo.foo(); -} -``` - -One fix may be to increase the recursion limit. Note that it is possible to -create an infinite recursion of dereferencing, in which case the only fix is to -somehow break the recursion. -"##, - -E0057: r##" -When invoking closures or other implementations of the function traits `Fn`, -`FnMut` or `FnOnce` using call notation, the number of parameters passed to the -function must match its definition. - -An example using a closure: - -```compile_fail,E0057 -let f = |x| x * 3; -let a = f(); // invalid, too few parameters -let b = f(4); // this works! -let c = f(2, 3); // invalid, too many parameters -``` - -A generic function must be treated similarly: - -``` -fn foo<F: Fn()>(f: F) { - f(); // this is valid, but f(3) would not work -} -``` -"##, - -E0059: r##" -The built-in function traits are generic over a tuple of the function arguments. -If one uses angle-bracket notation (`Fn<(T,), Output=U>`) instead of parentheses -(`Fn(T) -> U`) to denote the function trait, the type parameter should be a -tuple. Otherwise function call notation cannot be used and the trait will not be -implemented by closures. - -The most likely source of this error is using angle-bracket notation without -wrapping the function argument type into a tuple, for example: - -```compile_fail,E0059 -#![feature(unboxed_closures)] - -fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) } -``` - -It can be fixed by adjusting the trait bound like this: - -``` -#![feature(unboxed_closures)] - -fn foo<F: Fn<(i32,)>>(f: F) -> F::Output { f(3) } -``` - -Note that `(T,)` always denotes the type of a 1-tuple containing an element of -type `T`. The comma is necessary for syntactic disambiguation. -"##, - -E0060: r##" -External C functions are allowed to be variadic. However, a variadic function -takes a minimum number of arguments. For example, consider C's variadic `printf` -function: - -``` -use std::os::raw::{c_char, c_int}; - -extern "C" { - fn printf(_: *const c_char, ...) -> c_int; -} -``` - -Using this declaration, it must be called with at least one argument, so -simply calling `printf()` is invalid. But the following uses are allowed: - -``` -# #![feature(static_nobundle)] -# use std::os::raw::{c_char, c_int}; -# #[cfg_attr(all(windows, target_env = "msvc"), -# link(name = "legacy_stdio_definitions", kind = "static-nobundle"))] -# extern "C" { fn printf(_: *const c_char, ...) -> c_int; } -# fn main() { -unsafe { - use std::ffi::CString; - - let fmt = CString::new("test\n").unwrap(); - printf(fmt.as_ptr()); - - let fmt = CString::new("number = %d\n").unwrap(); - printf(fmt.as_ptr(), 3); - - let fmt = CString::new("%d, %d\n").unwrap(); - printf(fmt.as_ptr(), 10, 5); -} -# } -``` -"##, -// ^ Note: On MSVC 2015, the `printf` function is "inlined" in the C code, and -// the C runtime does not contain the `printf` definition. This leads to linker -// error from the doc test (issue #42830). -// This can be fixed by linking to the static library -// `legacy_stdio_definitions.lib` (see https://stackoverflow.com/a/36504365/). -// If this compatibility library is removed in the future, consider changing -// `printf` in this example to another well-known variadic function. - -E0061: r##" -The number of arguments passed to a function must match the number of arguments -specified in the function signature. - -For example, a function like: - -``` -fn f(a: u16, b: &str) {} -``` - -Must always be called with exactly two arguments, e.g., `f(2, "test")`. - -Note that Rust does not have a notion of optional function arguments or -variadic functions (except for its C-FFI). -"##, - -E0062: r##" -This error indicates that during an attempt to build a struct or struct-like -enum variant, one of the fields was specified more than once. Erroneous code -example: - -```compile_fail,E0062 -struct Foo { - x: i32, -} - -fn main() { - let x = Foo { - x: 0, - x: 0, // error: field `x` specified more than once - }; -} -``` - -Each field should be specified exactly one time. Example: - -``` -struct Foo { - x: i32, -} - -fn main() { - let x = Foo { x: 0 }; // ok! -} -``` -"##, - -E0063: r##" -This error indicates that during an attempt to build a struct or struct-like -enum variant, one of the fields was not provided. Erroneous code example: - -```compile_fail,E0063 -struct Foo { - x: i32, - y: i32, -} - -fn main() { - let x = Foo { x: 0 }; // error: missing field: `y` -} -``` - -Each field should be specified exactly once. Example: - -``` -struct Foo { - x: i32, - y: i32, -} - -fn main() { - let x = Foo { x: 0, y: 0 }; // ok! -} -``` -"##, - -E0067: r##" -The left-hand side of a compound assignment expression must be a place -expression. A place expression represents a memory location and includes -item paths (ie, namespaced variables), dereferences, indexing expressions, -and field references. - -Let's start with some erroneous code examples: - -```compile_fail,E0067 -use std::collections::LinkedList; - -// Bad: assignment to non-place expression -LinkedList::new() += 1; - -// ... - -fn some_func(i: &mut i32) { - i += 12; // Error : '+=' operation cannot be applied on a reference ! -} -``` - -And now some working examples: - -``` -let mut i : i32 = 0; - -i += 12; // Good ! - -// ... - -fn some_func(i: &mut i32) { - *i += 12; // Good ! -} -``` -"##, - -E0069: r##" -The compiler found a function whose body contains a `return;` statement but -whose return type is not `()`. An example of this is: - -```compile_fail,E0069 -// error -fn foo() -> u8 { - return; -} -``` - -Since `return;` is just like `return ();`, there is a mismatch between the -function's return type and the value being returned. -"##, - -E0070: r##" -The left-hand side of an assignment operator must be a place expression. A -place expression represents a memory location and can be a variable (with -optional namespacing), a dereference, an indexing expression or a field -reference. - -More details can be found in the [Expressions] section of the Reference. - -[Expressions]: https://doc.rust-lang.org/reference/expressions.html#places-rvalues-and-temporaries - -Now, we can go further. Here are some erroneous code examples: - -```compile_fail,E0070 -struct SomeStruct { - x: i32, - y: i32 -} - -const SOME_CONST : i32 = 12; - -fn some_other_func() {} - -fn some_function() { - SOME_CONST = 14; // error : a constant value cannot be changed! - 1 = 3; // error : 1 isn't a valid place! - some_other_func() = 4; // error : we cannot assign value to a function! - SomeStruct.x = 12; // error : SomeStruct a structure name but it is used - // like a variable! -} -``` - -And now let's give working examples: - -``` -struct SomeStruct { - x: i32, - y: i32 -} -let mut s = SomeStruct {x: 0, y: 0}; - -s.x = 3; // that's good ! - -// ... - -fn some_func(x: &mut i32) { - *x = 12; // that's good ! -} -``` -"##, - -E0071: r##" -You tried to use structure-literal syntax to create an item that is -not a structure or enum variant. - -Example of erroneous code: - -```compile_fail,E0071 -type U32 = u32; -let t = U32 { value: 4 }; // error: expected struct, variant or union type, - // found builtin type `u32` -``` - -To fix this, ensure that the name was correctly spelled, and that -the correct form of initializer was used. - -For example, the code above can be fixed to: - -``` -enum Foo { - FirstValue(i32) -} - -fn main() { - let u = Foo::FirstValue(0i32); - - let t = 4; -} -``` -"##, - -E0073: r##" -#### Note: this error code is no longer emitted by the compiler. - -You cannot define a struct (or enum) `Foo` that requires an instance of `Foo` -in order to make a new `Foo` value. This is because there would be no way a -first instance of `Foo` could be made to initialize another instance! - -Here's an example of a struct that has this problem: - -``` -struct Foo { x: Box<Foo> } // error -``` - -One fix is to use `Option`, like so: - -``` -struct Foo { x: Option<Box<Foo>> } -``` - -Now it's possible to create at least one instance of `Foo`: `Foo { x: None }`. -"##, - -E0074: r##" -#### Note: this error code is no longer emitted by the compiler. - -When using the `#[simd]` attribute on a tuple struct, the components of the -tuple struct must all be of a concrete, nongeneric type so the compiler can -reason about how to use SIMD with them. This error will occur if the types -are generic. - -This will cause an error: - -``` -#![feature(repr_simd)] - -#[repr(simd)] -struct Bad<T>(T, T, T); -``` - -This will not: - -``` -#![feature(repr_simd)] - -#[repr(simd)] -struct Good(u32, u32, u32); -``` -"##, - -E0075: r##" -The `#[simd]` attribute can only be applied to non empty tuple structs, because -it doesn't make sense to try to use SIMD operations when there are no values to -operate on. - -This will cause an error: - -```compile_fail,E0075 -#![feature(repr_simd)] - -#[repr(simd)] -struct Bad; -``` - -This will not: - -``` -#![feature(repr_simd)] - -#[repr(simd)] -struct Good(u32); -``` -"##, - -E0076: r##" -When using the `#[simd]` attribute to automatically use SIMD operations in tuple -struct, the types in the struct must all be of the same type, or the compiler -will trigger this error. - -This will cause an error: - -```compile_fail,E0076 -#![feature(repr_simd)] - -#[repr(simd)] -struct Bad(u16, u32, u32); -``` - -This will not: - -``` -#![feature(repr_simd)] - -#[repr(simd)] -struct Good(u32, u32, u32); -``` -"##, - -E0077: r##" -When using the `#[simd]` attribute on a tuple struct, the elements in the tuple -must be machine types so SIMD operations can be applied to them. - -This will cause an error: - -```compile_fail,E0077 -#![feature(repr_simd)] - -#[repr(simd)] -struct Bad(String); -``` - -This will not: - -``` -#![feature(repr_simd)] - -#[repr(simd)] -struct Good(u32, u32, u32); -``` -"##, - -E0081: r##" -Enum discriminants are used to differentiate enum variants stored in memory. -This error indicates that the same value was used for two or more variants, -making them impossible to tell apart. - -```compile_fail,E0081 -// Bad. -enum Enum { - P = 3, - X = 3, - Y = 5, -} -``` - -``` -// Good. -enum Enum { - P, - X = 3, - Y = 5, -} -``` - -Note that variants without a manually specified discriminant are numbered from -top to bottom starting from 0, so clashes can occur with seemingly unrelated -variants. - -```compile_fail,E0081 -enum Bad { - X, - Y = 0 -} -``` - -Here `X` will have already been specified the discriminant 0 by the time `Y` is -encountered, so a conflict occurs. -"##, - -E0084: r##" -An unsupported representation was attempted on a zero-variant enum. - -Erroneous code example: - -```compile_fail,E0084 -#[repr(i32)] -enum NightsWatch {} // error: unsupported representation for zero-variant enum -``` - -It is impossible to define an integer type to be used to represent zero-variant -enum values because there are no zero-variant enum values. There is no way to -construct an instance of the following type using only safe code. So you have -two solutions. Either you add variants in your enum: - -``` -#[repr(i32)] -enum NightsWatch { - JonSnow, - Commander, -} -``` - -or you remove the integer represention of your enum: - -``` -enum NightsWatch {} -``` -"##, - -// FIXME(const_generics:docs): example of inferring const parameter. -E0087: r##" -#### Note: this error code is no longer emitted by the compiler. - -Too many type arguments were supplied for a function. For example: - -```compile_fail,E0107 -fn foo<T>() {} - -fn main() { - foo::<f64, bool>(); // error: wrong number of type arguments: - // expected 1, found 2 -} -``` - -The number of supplied arguments must exactly match the number of defined type -parameters. -"##, - -E0088: r##" -#### Note: this error code is no longer emitted by the compiler. - -You gave too many lifetime arguments. Erroneous code example: - -```compile_fail,E0107 -fn f() {} - -fn main() { - f::<'static>() // error: wrong number of lifetime arguments: - // expected 0, found 1 -} -``` - -Please check you give the right number of lifetime arguments. Example: - -``` -fn f() {} - -fn main() { - f() // ok! -} -``` - -It's also important to note that the Rust compiler can generally -determine the lifetime by itself. Example: - -``` -struct Foo { - value: String -} - -impl Foo { - // it can be written like this - fn get_value<'a>(&'a self) -> &'a str { &self.value } - // but the compiler works fine with this too: - fn without_lifetime(&self) -> &str { &self.value } -} - -fn main() { - let f = Foo { value: "hello".to_owned() }; - - println!("{}", f.get_value()); - println!("{}", f.without_lifetime()); -} -``` -"##, - -E0089: r##" -#### Note: this error code is no longer emitted by the compiler. - -Too few type arguments were supplied for a function. For example: - -```compile_fail,E0107 -fn foo<T, U>() {} - -fn main() { - foo::<f64>(); // error: wrong number of type arguments: expected 2, found 1 -} -``` - -Note that if a function takes multiple type arguments but you want the compiler -to infer some of them, you can use type placeholders: - -```compile_fail,E0107 -fn foo<T, U>(x: T) {} - -fn main() { - let x: bool = true; - foo::<f64>(x); // error: wrong number of type arguments: - // expected 2, found 1 - foo::<_, f64>(x); // same as `foo::<bool, f64>(x)` -} -``` -"##, - -E0090: r##" -#### Note: this error code is no longer emitted by the compiler. - -You gave too few lifetime arguments. Example: - -```compile_fail,E0107 -fn foo<'a: 'b, 'b: 'a>() {} - -fn main() { - foo::<'static>(); // error: wrong number of lifetime arguments: - // expected 2, found 1 -} -``` - -Please check you give the right number of lifetime arguments. Example: - -``` -fn foo<'a: 'b, 'b: 'a>() {} - -fn main() { - foo::<'static, 'static>(); -} -``` -"##, - -E0091: r##" -You gave an unnecessary type or const parameter in a type alias. Erroneous -code example: - -```compile_fail,E0091 -type Foo<T> = u32; // error: type parameter `T` is unused -// or: -type Foo<A,B> = Box<A>; // error: type parameter `B` is unused -``` - -Please check you didn't write too many parameters. Example: - -``` -type Foo = u32; // ok! -type Foo2<A> = Box<A>; // ok! -``` -"##, - -E0092: r##" -You tried to declare an undefined atomic operation function. -Erroneous code example: - -```compile_fail,E0092 -#![feature(intrinsics)] - -extern "rust-intrinsic" { - fn atomic_foo(); // error: unrecognized atomic operation - // function -} -``` - -Please check you didn't make a mistake in the function's name. All intrinsic -functions are defined in librustc_codegen_llvm/intrinsic.rs and in -libcore/intrinsics.rs in the Rust source code. Example: - -``` -#![feature(intrinsics)] - -extern "rust-intrinsic" { - fn atomic_fence(); // ok! -} -``` -"##, - -E0093: r##" -You declared an unknown intrinsic function. Erroneous code example: - -```compile_fail,E0093 -#![feature(intrinsics)] - -extern "rust-intrinsic" { - fn foo(); // error: unrecognized intrinsic function: `foo` -} - -fn main() { - unsafe { - foo(); - } -} -``` - -Please check you didn't make a mistake in the function's name. All intrinsic -functions are defined in librustc_codegen_llvm/intrinsic.rs and in -libcore/intrinsics.rs in the Rust source code. Example: - -``` -#![feature(intrinsics)] - -extern "rust-intrinsic" { - fn atomic_fence(); // ok! -} - -fn main() { - unsafe { - atomic_fence(); - } -} -``` -"##, - -E0094: r##" -You gave an invalid number of type parameters to an intrinsic function. -Erroneous code example: - -```compile_fail,E0094 -#![feature(intrinsics)] - -extern "rust-intrinsic" { - fn size_of<T, U>() -> usize; // error: intrinsic has wrong number - // of type parameters -} -``` - -Please check that you provided the right number of type parameters -and verify with the function declaration in the Rust source code. -Example: - -``` -#![feature(intrinsics)] - -extern "rust-intrinsic" { - fn size_of<T>() -> usize; // ok! -} -``` -"##, - -E0107: r##" -This error means that an incorrect number of generic arguments were provided: - -```compile_fail,E0107 -struct Foo<T> { x: T } - -struct Bar { x: Foo } // error: wrong number of type arguments: - // expected 1, found 0 -struct Baz<S, T> { x: Foo<S, T> } // error: wrong number of type arguments: - // expected 1, found 2 - -fn foo<T, U>(x: T, y: U) {} - -fn main() { - let x: bool = true; - foo::<bool>(x); // error: wrong number of type arguments: - // expected 2, found 1 - foo::<bool, i32, i32>(x, 2, 4); // error: wrong number of type arguments: - // expected 2, found 3 -} - -fn f() {} - -fn main() { - f::<'static>(); // error: wrong number of lifetime arguments: - // expected 0, found 1 -} -``` - -"##, - -E0109: r##" -You tried to provide a generic argument to a type which doesn't need it. -Erroneous code example: - -```compile_fail,E0109 -type X = u32<i32>; // error: type arguments are not allowed for this type -type Y = bool<'static>; // error: lifetime parameters are not allowed on - // this type -``` - -Check that you used the correct argument and that the definition is correct. - -Example: - -``` -type X = u32; // ok! -type Y = bool; // ok! -``` - -Note that generic arguments for enum variant constructors go after the variant, -not after the enum. For example, you would write `Option::None::<u32>`, -rather than `Option::<u32>::None`. -"##, - -E0110: r##" -#### Note: this error code is no longer emitted by the compiler. - -You tried to provide a lifetime to a type which doesn't need it. -See `E0109` for more details. -"##, - -E0116: r##" -You can only define an inherent implementation for a type in the same crate -where the type was defined. For example, an `impl` block as below is not allowed -since `Vec` is defined in the standard library: - -```compile_fail,E0116 -impl Vec<u8> { } // error -``` - -To fix this problem, you can do either of these things: - - - define a trait that has the desired associated functions/types/constants and - implement the trait for the type in question - - define a new type wrapping the type and define an implementation on the new - type - -Note that using the `type` keyword does not work here because `type` only -introduces a type alias: - -```compile_fail,E0116 -type Bytes = Vec<u8>; - -impl Bytes { } // error, same as above -``` -"##, - -E0117: r##" -This error indicates a violation of one of Rust's orphan rules for trait -implementations. The rule prohibits any implementation of a foreign trait (a -trait defined in another crate) where - - - the type that is implementing the trait is foreign - - all of the parameters being passed to the trait (if there are any) are also - foreign. - -Here's one example of this error: - -```compile_fail,E0117 -impl Drop for u32 {} -``` - -To avoid this kind of error, ensure that at least one local type is referenced -by the `impl`: - -``` -pub struct Foo; // you define your type in your crate - -impl Drop for Foo { // and you can implement the trait on it! - // code of trait implementation here -# fn drop(&mut self) { } -} - -impl From<Foo> for i32 { // or you use a type from your crate as - // a type parameter - fn from(i: Foo) -> i32 { - 0 - } -} -``` - -Alternatively, define a trait locally and implement that instead: - -``` -trait Bar { - fn get(&self) -> usize; -} - -impl Bar for u32 { - fn get(&self) -> usize { 0 } -} -``` - -For information on the design of the orphan rules, see [RFC 1023]. - -[RFC 1023]: https://github.com/rust-lang/rfcs/blob/master/text/1023-rebalancing-coherence.md -"##, - -E0118: r##" -You're trying to write an inherent implementation for something which isn't a -struct nor an enum. Erroneous code example: - -```compile_fail,E0118 -impl (u8, u8) { // error: no base type found for inherent implementation - fn get_state(&self) -> String { - // ... - } -} -``` - -To fix this error, please implement a trait on the type or wrap it in a struct. -Example: - -``` -// we create a trait here -trait LiveLongAndProsper { - fn get_state(&self) -> String; -} - -// and now you can implement it on (u8, u8) -impl LiveLongAndProsper for (u8, u8) { - fn get_state(&self) -> String { - "He's dead, Jim!".to_owned() - } -} -``` - -Alternatively, you can create a newtype. A newtype is a wrapping tuple-struct. -For example, `NewType` is a newtype over `Foo` in `struct NewType(Foo)`. -Example: - -``` -struct TypeWrapper((u8, u8)); - -impl TypeWrapper { - fn get_state(&self) -> String { - "Fascinating!".to_owned() - } -} -``` -"##, - -E0120: r##" -An attempt was made to implement Drop on a trait, which is not allowed: only -structs and enums can implement Drop. An example causing this error: - -```compile_fail,E0120 -trait MyTrait {} - -impl Drop for MyTrait { - fn drop(&mut self) {} -} -``` - -A workaround for this problem is to wrap the trait up in a struct, and implement -Drop on that. An example is shown below: - -``` -trait MyTrait {} -struct MyWrapper<T: MyTrait> { foo: T } - -impl <T: MyTrait> Drop for MyWrapper<T> { - fn drop(&mut self) {} -} - -``` - -Alternatively, wrapping trait objects requires something like the following: - -``` -trait MyTrait {} - -//or Box<MyTrait>, if you wanted an owned trait object -struct MyWrapper<'a> { foo: &'a MyTrait } - -impl <'a> Drop for MyWrapper<'a> { - fn drop(&mut self) {} -} -``` -"##, - -E0121: r##" -In order to be consistent with Rust's lack of global type inference, -type and const placeholders are disallowed by design in item signatures. - -Examples of this error include: - -```compile_fail,E0121 -fn foo() -> _ { 5 } // error, explicitly write out the return type instead - -static BAR: _ = "test"; // error, explicitly write out the type instead -``` -"##, - -E0124: r##" -You declared two fields of a struct with the same name. Erroneous code -example: - -```compile_fail,E0124 -struct Foo { - field1: i32, - field1: i32, // error: field is already declared -} -``` - -Please verify that the field names have been correctly spelled. Example: - -``` -struct Foo { - field1: i32, - field2: i32, // ok! -} -``` -"##, - -E0131: r##" -It is not possible to define `main` with generic parameters. -When `main` is present, it must take no arguments and return `()`. -Erroneous code example: - -```compile_fail,E0131 -fn main<T>() { // error: main function is not allowed to have generic parameters -} -``` -"##, - -E0132: r##" -A function with the `start` attribute was declared with type parameters. - -Erroneous code example: - -```compile_fail,E0132 -#![feature(start)] - -#[start] -fn f<T>() {} -``` - -It is not possible to declare type parameters on a function that has the `start` -attribute. Such a function must have the following type signature (for more -information, view [the unstable book][1]): - -[1]: https://doc.rust-lang.org/unstable-book/language-features/lang-items.html#writing-an-executable-without-stdlib - -``` -# let _: -fn(isize, *const *const u8) -> isize; -``` - -Example: - -``` -#![feature(start)] - -#[start] -fn my_start(argc: isize, argv: *const *const u8) -> isize { - 0 -} -``` -"##, - -E0164: r##" -This error means that an attempt was made to match a struct type enum -variant as a non-struct type: - -```compile_fail,E0164 -enum Foo { B { i: u32 } } - -fn bar(foo: Foo) -> u32 { - match foo { - Foo::B(i) => i, // error E0164 - } -} -``` - -Try using `{}` instead: - -``` -enum Foo { B { i: u32 } } - -fn bar(foo: Foo) -> u32 { - match foo { - Foo::B{i} => i, - } -} -``` -"##, - -E0184: r##" -Explicitly implementing both Drop and Copy for a type is currently disallowed. -This feature can make some sense in theory, but the current implementation is -incorrect and can lead to memory unsafety (see [issue #20126][iss20126]), so -it has been disabled for now. - -[iss20126]: https://github.com/rust-lang/rust/issues/20126 -"##, - -E0185: r##" -An associated function for a trait was defined to be static, but an -implementation of the trait declared the same function to be a method (i.e., to -take a `self` parameter). - -Here's an example of this error: - -```compile_fail,E0185 -trait Foo { - fn foo(); -} - -struct Bar; - -impl Foo for Bar { - // error, method `foo` has a `&self` declaration in the impl, but not in - // the trait - fn foo(&self) {} -} -``` -"##, - -E0186: r##" -An associated function for a trait was defined to be a method (i.e., to take a -`self` parameter), but an implementation of the trait declared the same function -to be static. - -Here's an example of this error: - -```compile_fail,E0186 -trait Foo { - fn foo(&self); -} - -struct Bar; - -impl Foo for Bar { - // error, method `foo` has a `&self` declaration in the trait, but not in - // the impl - fn foo() {} -} -``` -"##, - -E0191: r##" -Trait objects need to have all associated types specified. Erroneous code -example: - -```compile_fail,E0191 -trait Trait { - type Bar; -} - -type Foo = Trait; // error: the value of the associated type `Bar` (from - // the trait `Trait`) must be specified -``` - -Please verify you specified all associated types of the trait and that you -used the right trait. Example: - -``` -trait Trait { - type Bar; -} - -type Foo = Trait<Bar=i32>; // ok! -``` -"##, - -E0192: r##" -Negative impls are only allowed for auto traits. For more -information see the [opt-in builtin traits RFC][RFC 19]. - -[RFC 19]: https://github.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md -"##, - -E0193: r##" -#### Note: this error code is no longer emitted by the compiler. - -`where` clauses must use generic type parameters: it does not make sense to use -them otherwise. An example causing this error: - -``` -trait Foo { - fn bar(&self); -} - -#[derive(Copy,Clone)] -struct Wrapper<T> { - Wrapped: T -} - -impl Foo for Wrapper<u32> where Wrapper<u32>: Clone { - fn bar(&self) { } -} -``` - -This use of a `where` clause is strange - a more common usage would look -something like the following: - -``` -trait Foo { - fn bar(&self); -} - -#[derive(Copy,Clone)] -struct Wrapper<T> { - Wrapped: T -} -impl <T> Foo for Wrapper<T> where Wrapper<T>: Clone { - fn bar(&self) { } -} -``` - -Here, we're saying that the implementation exists on Wrapper only when the -wrapped type `T` implements `Clone`. The `where` clause is important because -some types will not implement `Clone`, and thus will not get this method. - -In our erroneous example, however, we're referencing a single concrete type. -Since we know for certain that `Wrapper<u32>` implements `Clone`, there's no -reason to also specify it in a `where` clause. -"##, - -E0195: r##" -Your method's lifetime parameters do not match the trait declaration. -Erroneous code example: - -```compile_fail,E0195 -trait Trait { - fn bar<'a,'b:'a>(x: &'a str, y: &'b str); -} - -struct Foo; - -impl Trait for Foo { - fn bar<'a,'b>(x: &'a str, y: &'b str) { - // error: lifetime parameters or bounds on method `bar` - // do not match the trait declaration - } -} -``` - -The lifetime constraint `'b` for bar() implementation does not match the -trait declaration. Ensure lifetime declarations match exactly in both trait -declaration and implementation. Example: - -``` -trait Trait { - fn t<'a,'b:'a>(x: &'a str, y: &'b str); -} - -struct Foo; - -impl Trait for Foo { - fn t<'a,'b:'a>(x: &'a str, y: &'b str) { // ok! - } -} -``` -"##, - -E0199: r##" -Safe traits should not have unsafe implementations, therefore marking an -implementation for a safe trait unsafe will cause a compiler error. Removing -the unsafe marker on the trait noted in the error will resolve this problem. - -```compile_fail,E0199 -struct Foo; - -trait Bar { } - -// this won't compile because Bar is safe -unsafe impl Bar for Foo { } -// this will compile -impl Bar for Foo { } -``` -"##, - -E0200: r##" -Unsafe traits must have unsafe implementations. This error occurs when an -implementation for an unsafe trait isn't marked as unsafe. This may be resolved -by marking the unsafe implementation as unsafe. - -```compile_fail,E0200 -struct Foo; - -unsafe trait Bar { } - -// this won't compile because Bar is unsafe and impl isn't unsafe -impl Bar for Foo { } -// this will compile -unsafe impl Bar for Foo { } -``` -"##, - -E0201: r##" -It is an error to define two associated items (like methods, associated types, -associated functions, etc.) with the same identifier. - -For example: - -```compile_fail,E0201 -struct Foo(u8); - -impl Foo { - fn bar(&self) -> bool { self.0 > 5 } - fn bar() {} // error: duplicate associated function -} - -trait Baz { - type Quux; - fn baz(&self) -> bool; -} - -impl Baz for Foo { - type Quux = u32; - - fn baz(&self) -> bool { true } - - // error: duplicate method - fn baz(&self) -> bool { self.0 > 5 } - - // error: duplicate associated type - type Quux = u32; -} -``` - -Note, however, that items with the same name are allowed for inherent `impl` -blocks that don't overlap: - -``` -struct Foo<T>(T); - -impl Foo<u8> { - fn bar(&self) -> bool { self.0 > 5 } -} - -impl Foo<bool> { - fn bar(&self) -> bool { self.0 } -} -``` -"##, - -E0202: r##" -Inherent associated types were part of [RFC 195] but are not yet implemented. -See [the tracking issue][iss8995] for the status of this implementation. - -[RFC 195]: https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-items.md -[iss8995]: https://github.com/rust-lang/rust/issues/8995 -"##, - -E0204: r##" -An attempt to implement the `Copy` trait for a struct failed because one of the -fields does not implement `Copy`. To fix this, you must implement `Copy` for the -mentioned field. Note that this may not be possible, as in the example of - -```compile_fail,E0204 -struct Foo { - foo : Vec<u32>, -} - -impl Copy for Foo { } -``` - -This fails because `Vec<T>` does not implement `Copy` for any `T`. - -Here's another example that will fail: - -```compile_fail,E0204 -#[derive(Copy)] -struct Foo<'a> { - ty: &'a mut bool, -} -``` - -This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this -differs from the behavior for `&T`, which is always `Copy`). -"##, - -E0205: r##" -#### Note: this error code is no longer emitted by the compiler. - -An attempt to implement the `Copy` trait for an enum failed because one of the -variants does not implement `Copy`. To fix this, you must implement `Copy` for -the mentioned variant. Note that this may not be possible, as in the example of - -```compile_fail,E0204 -enum Foo { - Bar(Vec<u32>), - Baz, -} - -impl Copy for Foo { } -``` - -This fails because `Vec<T>` does not implement `Copy` for any `T`. - -Here's another example that will fail: - -```compile_fail,E0204 -#[derive(Copy)] -enum Foo<'a> { - Bar(&'a mut bool), - Baz, -} -``` - -This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this -differs from the behavior for `&T`, which is always `Copy`). -"##, - -E0206: r##" -You can only implement `Copy` for a struct or enum. Both of the following -examples will fail, because neither `[u8; 256]` nor `&'static mut Bar` -(mutable reference to `Bar`) is a struct or enum: - -```compile_fail,E0206 -type Foo = [u8; 256]; -impl Copy for Foo { } // error - -#[derive(Copy, Clone)] -struct Bar; -impl Copy for &'static mut Bar { } // error -``` -"##, - -E0207: r##" -Any type parameter or lifetime parameter of an `impl` must meet at least one of -the following criteria: - - - it appears in the _implementing type_ of the impl, e.g. `impl<T> Foo<T>` - - for a trait impl, it appears in the _implemented trait_, e.g. - `impl<T> SomeTrait<T> for Foo` - - it is bound as an associated type, e.g. `impl<T, U> SomeTrait for T - where T: AnotherTrait<AssocType=U>` - -### Error example 1 - -Suppose we have a struct `Foo` and we would like to define some methods for it. -The following definition leads to a compiler error: - -```compile_fail,E0207 -struct Foo; - -impl<T: Default> Foo { -// error: the type parameter `T` is not constrained by the impl trait, self -// type, or predicates [E0207] - fn get(&self) -> T { - <T as Default>::default() - } -} -``` - -The problem is that the parameter `T` does not appear in the implementing type -(`Foo`) of the impl. In this case, we can fix the error by moving the type -parameter from the `impl` to the method `get`: - - -``` -struct Foo; - -// Move the type parameter from the impl to the method -impl Foo { - fn get<T: Default>(&self) -> T { - <T as Default>::default() - } -} -``` - -### Error example 2 - -As another example, suppose we have a `Maker` trait and want to establish a -type `FooMaker` that makes `Foo`s: - -```compile_fail,E0207 -trait Maker { - type Item; - fn make(&mut self) -> Self::Item; -} - -struct Foo<T> { - foo: T -} - -struct FooMaker; - -impl<T: Default> Maker for FooMaker { -// error: the type parameter `T` is not constrained by the impl trait, self -// type, or predicates [E0207] - type Item = Foo<T>; - - fn make(&mut self) -> Foo<T> { - Foo { foo: <T as Default>::default() } - } -} -``` - -This fails to compile because `T` does not appear in the trait or in the -implementing type. - -One way to work around this is to introduce a phantom type parameter into -`FooMaker`, like so: - -``` -use std::marker::PhantomData; - -trait Maker { - type Item; - fn make(&mut self) -> Self::Item; -} - -struct Foo<T> { - foo: T -} - -// Add a type parameter to `FooMaker` -struct FooMaker<T> { - phantom: PhantomData<T>, -} - -impl<T: Default> Maker for FooMaker<T> { - type Item = Foo<T>; - - fn make(&mut self) -> Foo<T> { - Foo { - foo: <T as Default>::default(), - } - } -} -``` - -Another way is to do away with the associated type in `Maker` and use an input -type parameter instead: - -``` -// Use a type parameter instead of an associated type here -trait Maker<Item> { - fn make(&mut self) -> Item; -} - -struct Foo<T> { - foo: T -} - -struct FooMaker; - -impl<T: Default> Maker<Foo<T>> for FooMaker { - fn make(&mut self) -> Foo<T> { - Foo { foo: <T as Default>::default() } - } -} -``` - -### Additional information - -For more information, please see [RFC 447]. - -[RFC 447]: https://github.com/rust-lang/rfcs/blob/master/text/0447-no-unused-impl-parameters.md -"##, - -E0210: r##" -This error indicates a violation of one of Rust's orphan rules for trait -implementations. The rule concerns the use of type parameters in an -implementation of a foreign trait (a trait defined in another crate), and -states that type parameters must be "covered" by a local type. - -When implementing a foreign trait for a foreign type, -the trait must have one or more type parameters. -A type local to your crate must appear before any use of any type parameters. - -To understand what this means, it is perhaps easier to consider a few examples. - -If `ForeignTrait` is a trait defined in some external crate `foo`, then the -following trait `impl` is an error: - -```compile_fail,E0210 -# #[cfg(for_demonstration_only)] -extern crate foo; -# #[cfg(for_demonstration_only)] -use foo::ForeignTrait; -# use std::panic::UnwindSafe as ForeignTrait; - -impl<T> ForeignTrait for T { } // error -# fn main() {} -``` - -To work around this, it can be covered with a local type, `MyType`: - -``` -# use std::panic::UnwindSafe as ForeignTrait; -struct MyType<T>(T); -impl<T> ForeignTrait for MyType<T> { } // Ok -``` - -Please note that a type alias is not sufficient. - -For another example of an error, suppose there's another trait defined in `foo` -named `ForeignTrait2` that takes two type parameters. Then this `impl` results -in the same rule violation: - -```ignore (cannot-doctest-multicrate-project) -struct MyType2; -impl<T> ForeignTrait2<T, MyType<T>> for MyType2 { } // error -``` - -The reason for this is that there are two appearances of type parameter `T` in -the `impl` header, both as parameters for `ForeignTrait2`. The first appearance -is uncovered, and so runs afoul of the orphan rule. - -Consider one more example: - -```ignore (cannot-doctest-multicrate-project) -impl<T> ForeignTrait2<MyType<T>, T> for MyType2 { } // Ok -``` - -This only differs from the previous `impl` in that the parameters `T` and -`MyType<T>` for `ForeignTrait2` have been swapped. This example does *not* -violate the orphan rule; it is permitted. - -To see why that last example was allowed, you need to understand the general -rule. Unfortunately this rule is a bit tricky to state. Consider an `impl`: - -```ignore (only-for-syntax-highlight) -impl<P1, ..., Pm> ForeignTrait<T1, ..., Tn> for T0 { ... } -``` - -where `P1, ..., Pm` are the type parameters of the `impl` and `T0, ..., Tn` -are types. One of the types `T0, ..., Tn` must be a local type (this is another -orphan rule, see the explanation for E0117). - -Both of the following must be true: -1. At least one of the types `T0..=Tn` must be a local type. -Let `Ti` be the first such type. -2. No uncovered type parameters `P1..=Pm` may appear in `T0..Ti` -(excluding `Ti`). - -For information on the design of the orphan rules, -see [RFC 2451] and [RFC 1023]. - -[RFC 2451]: https://rust-lang.github.io/rfcs/2451-re-rebalancing-coherence.html -[RFC 1023]: https://github.com/rust-lang/rfcs/blob/master/text/1023-rebalancing-coherence.md -"##, - -E0211: r##" -#### Note: this error code is no longer emitted by the compiler. - -You used a function or type which doesn't fit the requirements for where it was -used. Erroneous code examples: - -```compile_fail -#![feature(intrinsics)] - -extern "rust-intrinsic" { - fn size_of<T>(); // error: intrinsic has wrong type -} - -// or: - -fn main() -> i32 { 0 } -// error: main function expects type: `fn() {main}`: expected (), found i32 - -// or: - -let x = 1u8; -match x { - 0u8..=3i8 => (), - // error: mismatched types in range: expected u8, found i8 - _ => () -} - -// or: - -use std::rc::Rc; -struct Foo; - -impl Foo { - fn x(self: Rc<Foo>) {} - // error: mismatched self type: expected `Foo`: expected struct - // `Foo`, found struct `alloc::rc::Rc` -} -``` - -For the first code example, please check the function definition. Example: - -``` -#![feature(intrinsics)] - -extern "rust-intrinsic" { - fn size_of<T>() -> usize; // ok! -} -``` - -The second case example is a bit particular: the main function must always -have this definition: - -```compile_fail -fn main(); -``` - -They never take parameters and never return types. - -For the third example, when you match, all patterns must have the same type -as the type you're matching on. Example: - -``` -let x = 1u8; - -match x { - 0u8..=3u8 => (), // ok! - _ => () -} -``` - -And finally, for the last example, only `Box<Self>`, `&Self`, `Self`, -or `&mut Self` work as explicit self parameters. Example: - -``` -struct Foo; - -impl Foo { - fn x(self: Box<Foo>) {} // ok! -} -``` -"##, - -E0220: r##" -You used an associated type which isn't defined in the trait. -Erroneous code example: - -```compile_fail,E0220 -trait T1 { - type Bar; -} - -type Foo = T1<F=i32>; // error: associated type `F` not found for `T1` - -// or: - -trait T2 { - type Bar; - - // error: Baz is used but not declared - fn return_bool(&self, _: &Self::Bar, _: &Self::Baz) -> bool; -} -``` - -Make sure that you have defined the associated type in the trait body. -Also, verify that you used the right trait or you didn't misspell the -associated type name. Example: - -``` -trait T1 { - type Bar; -} - -type Foo = T1<Bar=i32>; // ok! - -// or: - -trait T2 { - type Bar; - type Baz; // we declare `Baz` in our trait. - - // and now we can use it here: - fn return_bool(&self, _: &Self::Bar, _: &Self::Baz) -> bool; -} -``` -"##, - -E0221: r##" -An attempt was made to retrieve an associated type, but the type was ambiguous. -For example: - -```compile_fail,E0221 -trait T1 {} -trait T2 {} - -trait Foo { - type A: T1; -} - -trait Bar : Foo { - type A: T2; - fn do_something() { - let _: Self::A; - } -} -``` - -In this example, `Foo` defines an associated type `A`. `Bar` inherits that type -from `Foo`, and defines another associated type of the same name. As a result, -when we attempt to use `Self::A`, it's ambiguous whether we mean the `A` defined -by `Foo` or the one defined by `Bar`. - -There are two options to work around this issue. The first is simply to rename -one of the types. Alternatively, one can specify the intended type using the -following syntax: - -``` -trait T1 {} -trait T2 {} - -trait Foo { - type A: T1; -} - -trait Bar : Foo { - type A: T2; - fn do_something() { - let _: <Self as Bar>::A; - } -} -``` -"##, - -E0223: r##" -An attempt was made to retrieve an associated type, but the type was ambiguous. -For example: - -```compile_fail,E0223 -trait MyTrait {type X; } - -fn main() { - let foo: MyTrait::X; -} -``` - -The problem here is that we're attempting to take the type of X from MyTrait. -Unfortunately, the type of X is not defined, because it's only made concrete in -implementations of the trait. A working version of this code might look like: - -``` -trait MyTrait {type X; } -struct MyStruct; - -impl MyTrait for MyStruct { - type X = u32; -} - -fn main() { - let foo: <MyStruct as MyTrait>::X; -} -``` - -This syntax specifies that we want the X type from MyTrait, as made concrete in -MyStruct. The reason that we cannot simply use `MyStruct::X` is that MyStruct -might implement two different traits with identically-named associated types. -This syntax allows disambiguation between the two. -"##, - -E0225: r##" -You attempted to use multiple types as bounds for a closure or trait object. -Rust does not currently support this. A simple example that causes this error: - -```compile_fail,E0225 -fn main() { - let _: Box<dyn std::io::Read + std::io::Write>; -} -``` - -Auto traits such as Send and Sync are an exception to this rule: -It's possible to have bounds of one non-builtin trait, plus any number of -auto traits. For example, the following compiles correctly: - -``` -fn main() { - let _: Box<dyn std::io::Read + Send + Sync>; -} -``` -"##, - -E0229: r##" -An associated type binding was done outside of the type parameter declaration -and `where` clause. Erroneous code example: - -```compile_fail,E0229 -pub trait Foo { - type A; - fn boo(&self) -> <Self as Foo>::A; -} - -struct Bar; - -impl Foo for isize { - type A = usize; - fn boo(&self) -> usize { 42 } -} - -fn baz<I>(x: &<I as Foo<A=Bar>>::A) {} -// error: associated type bindings are not allowed here -``` - -To solve this error, please move the type bindings in the type parameter -declaration: - -``` -# struct Bar; -# trait Foo { type A; } -fn baz<I: Foo<A=Bar>>(x: &<I as Foo>::A) {} // ok! -``` - -Or in the `where` clause: - -``` -# struct Bar; -# trait Foo { type A; } -fn baz<I>(x: &<I as Foo>::A) where I: Foo<A=Bar> {} -``` -"##, - -E0243: r##" -#### Note: this error code is no longer emitted by the compiler. - -This error indicates that not enough type parameters were found in a type or -trait. - -For example, the `Foo` struct below is defined to be generic in `T`, but the -type parameter is missing in the definition of `Bar`: - -```compile_fail,E0107 -struct Foo<T> { x: T } - -struct Bar { x: Foo } -``` -"##, - -E0244: r##" -#### Note: this error code is no longer emitted by the compiler. - -This error indicates that too many type parameters were found in a type or -trait. - -For example, the `Foo` struct below has no type parameters, but is supplied -with two in the definition of `Bar`: - -```compile_fail,E0107 -struct Foo { x: bool } - -struct Bar<S, T> { x: Foo<S, T> } -``` -"##, - -E0307: r##" -This error indicates that the `self` parameter in a method has an invalid -"reciever type". - -Methods take a special first parameter, of which there are three variants: -`self`, `&self`, and `&mut self`. These are syntactic sugar for -`self: Self`, `self: &Self`, and `self: &mut Self` respectively. - -``` -# struct Foo; -trait Trait { - fn foo(&self); -// ^^^^^ `self` here is a reference to the receiver object -} - -impl Trait for Foo { - fn foo(&self) {} -// ^^^^^ the receiver type is `&Foo` -} -``` - -The type `Self` acts as an alias to the type of the current trait -implementer, or "receiver type". Besides the already mentioned `Self`, -`&Self` and `&mut Self` valid receiver types, the following are also valid: -`self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, and `self: Pin<P>` -(where P is one of the previous types except `Self`). Note that `Self` can -also be the underlying implementing type, like `Foo` in the following -example: - -``` -# struct Foo; -# trait Trait { -# fn foo(&self); -# } -impl Trait for Foo { - fn foo(self: &Foo) {} -} -``` - -E0307 will be emitted by the compiler when using an invalid reciver type, -like in the following example: - -```compile_fail,E0307 -# struct Foo; -# struct Bar; -# trait Trait { -# fn foo(&self); -# } -impl Trait for Foo { - fn foo(self: &Bar) {} -} -``` - -The nightly feature [Arbintrary self types][AST] extends the accepted -set of receiver types to also include any type that can dereference to -`Self`: - -``` -#![feature(arbitrary_self_types)] - -struct Foo; -struct Bar; - -// Because you can dereference `Bar` into `Foo`... -impl std::ops::Deref for Bar { - type Target = Foo; - - fn deref(&self) -> &Foo { - &Foo - } -} - -impl Foo { - fn foo(self: Bar) {} -// ^^^^^^^^^ ...it can be used as the receiver type -} -``` - -[AST]: https://doc.rust-lang.org/unstable-book/language-features/arbitrary-self-types.html -"##, - -E0321: r##" -A cross-crate opt-out trait was implemented on something which wasn't a struct -or enum type. Erroneous code example: - -```compile_fail,E0321 -#![feature(optin_builtin_traits)] - -struct Foo; - -impl !Sync for Foo {} - -unsafe impl Send for &'static Foo {} -// error: cross-crate traits with a default impl, like `core::marker::Send`, -// can only be implemented for a struct/enum type, not -// `&'static Foo` -``` - -Only structs and enums are permitted to impl Send, Sync, and other opt-out -trait, and the struct or enum must be local to the current crate. So, for -example, `unsafe impl Send for Rc<Foo>` is not allowed. -"##, - -E0322: r##" -The `Sized` trait is a special trait built-in to the compiler for types with a -constant size known at compile-time. This trait is automatically implemented -for types as needed by the compiler, and it is currently disallowed to -explicitly implement it for a type. -"##, - -E0323: r##" -An associated const was implemented when another trait item was expected. -Erroneous code example: - -```compile_fail,E0323 -trait Foo { - type N; -} - -struct Bar; - -impl Foo for Bar { - const N : u32 = 0; - // error: item `N` is an associated const, which doesn't match its - // trait `<Bar as Foo>` -} -``` - -Please verify that the associated const wasn't misspelled and the correct trait -was implemented. Example: - -``` -struct Bar; - -trait Foo { - type N; -} - -impl Foo for Bar { - type N = u32; // ok! -} -``` - -Or: - -``` -struct Bar; - -trait Foo { - const N : u32; -} - -impl Foo for Bar { - const N : u32 = 0; // ok! -} -``` -"##, - -E0324: r##" -A method was implemented when another trait item was expected. Erroneous -code example: - -```compile_fail,E0324 -struct Bar; - -trait Foo { - const N : u32; - - fn M(); -} - -impl Foo for Bar { - fn N() {} - // error: item `N` is an associated method, which doesn't match its - // trait `<Bar as Foo>` -} -``` - -To fix this error, please verify that the method name wasn't misspelled and -verify that you are indeed implementing the correct trait items. Example: - -``` -struct Bar; - -trait Foo { - const N : u32; - - fn M(); -} - -impl Foo for Bar { - const N : u32 = 0; - - fn M() {} // ok! -} -``` -"##, - -E0325: r##" -An associated type was implemented when another trait item was expected. -Erroneous code example: - -```compile_fail,E0325 -struct Bar; - -trait Foo { - const N : u32; -} - -impl Foo for Bar { - type N = u32; - // error: item `N` is an associated type, which doesn't match its - // trait `<Bar as Foo>` -} -``` - -Please verify that the associated type name wasn't misspelled and your -implementation corresponds to the trait definition. Example: - -``` -struct Bar; - -trait Foo { - type N; -} - -impl Foo for Bar { - type N = u32; // ok! -} -``` - -Or: - -``` -struct Bar; - -trait Foo { - const N : u32; -} - -impl Foo for Bar { - const N : u32 = 0; // ok! -} -``` -"##, - -E0326: r##" -The types of any associated constants in a trait implementation must match the -types in the trait definition. This error indicates that there was a mismatch. - -Here's an example of this error: - -```compile_fail,E0326 -trait Foo { - const BAR: bool; -} - -struct Bar; - -impl Foo for Bar { - const BAR: u32 = 5; // error, expected bool, found u32 -} -``` -"##, - -E0328: r##" -The Unsize trait should not be implemented directly. All implementations of -Unsize are provided automatically by the compiler. - -Erroneous code example: - -```compile_fail,E0328 -#![feature(unsize)] - -use std::marker::Unsize; - -pub struct MyType; - -impl<T> Unsize<T> for MyType {} -``` - -If you are defining your own smart pointer type and would like to enable -conversion from a sized to an unsized type with the -[DST coercion system][RFC 982], use [`CoerceUnsized`] instead. - -``` -#![feature(coerce_unsized)] - -use std::ops::CoerceUnsized; - -pub struct MyType<T: ?Sized> { - field_with_unsized_type: T, -} - -impl<T, U> CoerceUnsized<MyType<U>> for MyType<T> - where T: CoerceUnsized<U> {} -``` - -[RFC 982]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md -[`CoerceUnsized`]: https://doc.rust-lang.org/std/ops/trait.CoerceUnsized.html -"##, - -E0329: r##" -#### Note: this error code is no longer emitted by the compiler. - -An attempt was made to access an associated constant through either a generic -type parameter or `Self`. This is not supported yet. An example causing this -error is shown below: - -``` -trait Foo { - const BAR: f64; -} - -struct MyStruct; - -impl Foo for MyStruct { - const BAR: f64 = 0f64; -} - -fn get_bar_bad<F: Foo>(t: F) -> f64 { - F::BAR -} -``` - -Currently, the value of `BAR` for a particular type can only be accessed -through a concrete type, as shown below: - -``` -trait Foo { - const BAR: f64; -} - -struct MyStruct; - -impl Foo for MyStruct { - const BAR: f64 = 0f64; -} - -fn get_bar_good() -> f64 { - <MyStruct as Foo>::BAR -} -``` -"##, - -E0366: r##" -An attempt was made to implement `Drop` on a concrete specialization of a -generic type. An example is shown below: - -```compile_fail,E0366 -struct Foo<T> { - t: T -} - -impl Drop for Foo<u32> { - fn drop(&mut self) {} -} -``` - -This code is not legal: it is not possible to specialize `Drop` to a subset of -implementations of a generic type. One workaround for this is to wrap the -generic type, as shown below: - -``` -struct Foo<T> { - t: T -} - -struct Bar { - t: Foo<u32> -} - -impl Drop for Bar { - fn drop(&mut self) {} -} -``` -"##, - -E0367: r##" -An attempt was made to implement `Drop` on a specialization of a generic type. -An example is shown below: - -```compile_fail,E0367 -trait Foo{} - -struct MyStruct<T> { - t: T -} - -impl<T: Foo> Drop for MyStruct<T> { - fn drop(&mut self) {} -} -``` - -This code is not legal: it is not possible to specialize `Drop` to a subset of -implementations of a generic type. In order for this code to work, `MyStruct` -must also require that `T` implements `Foo`. Alternatively, another option is -to wrap the generic type in another that specializes appropriately: - -``` -trait Foo{} - -struct MyStruct<T> { - t: T -} - -struct MyStructWrapper<T: Foo> { - t: MyStruct<T> -} - -impl <T: Foo> Drop for MyStructWrapper<T> { - fn drop(&mut self) {} -} -``` -"##, - -E0368: r##" -This error indicates that a binary assignment operator like `+=` or `^=` was -applied to a type that doesn't support it. For example: - -```compile_fail,E0368 -let mut x = 12f32; // error: binary operation `<<` cannot be applied to - // type `f32` - -x <<= 2; -``` - -To fix this error, please check that this type implements this binary -operation. Example: - -``` -let mut x = 12u32; // the `u32` type does implement the `ShlAssign` trait - -x <<= 2; // ok! -``` - -It is also possible to overload most operators for your own type by -implementing the `[OP]Assign` traits from `std::ops`. - -Another problem you might be facing is this: suppose you've overloaded the `+` -operator for some type `Foo` by implementing the `std::ops::Add` trait for -`Foo`, but you find that using `+=` does not work, as in this example: - -```compile_fail,E0368 -use std::ops::Add; - -struct Foo(u32); - -impl Add for Foo { - type Output = Foo; - - fn add(self, rhs: Foo) -> Foo { - Foo(self.0 + rhs.0) - } -} - -fn main() { - let mut x: Foo = Foo(5); - x += Foo(7); // error, `+= cannot be applied to the type `Foo` -} -``` - -This is because `AddAssign` is not automatically implemented, so you need to -manually implement it for your type. -"##, - -E0369: r##" -A binary operation was attempted on a type which doesn't support it. -Erroneous code example: - -```compile_fail,E0369 -let x = 12f32; // error: binary operation `<<` cannot be applied to - // type `f32` - -x << 2; -``` - -To fix this error, please check that this type implements this binary -operation. Example: - -``` -let x = 12u32; // the `u32` type does implement it: - // https://doc.rust-lang.org/stable/std/ops/trait.Shl.html - -x << 2; // ok! -``` - -It is also possible to overload most operators for your own type by -implementing traits from `std::ops`. - -String concatenation appends the string on the right to the string on the -left and may require reallocation. This requires ownership of the string -on the left. If something should be added to a string literal, move the -literal to the heap by allocating it with `to_owned()` like in -`"Your text".to_owned()`. - -"##, - -E0370: r##" -The maximum value of an enum was reached, so it cannot be automatically -set in the next enum value. Erroneous code example: - -```compile_fail,E0370 -#[repr(i64)] -enum Foo { - X = 0x7fffffffffffffff, - Y, // error: enum discriminant overflowed on value after - // 9223372036854775807: i64; set explicitly via - // Y = -9223372036854775808 if that is desired outcome -} -``` - -To fix this, please set manually the next enum value or put the enum variant -with the maximum value at the end of the enum. Examples: - -``` -#[repr(i64)] -enum Foo { - X = 0x7fffffffffffffff, - Y = 0, // ok! -} -``` - -Or: - -``` -#[repr(i64)] -enum Foo { - Y = 0, // ok! - X = 0x7fffffffffffffff, -} -``` -"##, - -E0371: r##" -When `Trait2` is a subtrait of `Trait1` (for example, when `Trait2` has a -definition like `trait Trait2: Trait1 { ... }`), it is not allowed to implement -`Trait1` for `Trait2`. This is because `Trait2` already implements `Trait1` by -definition, so it is not useful to do this. - -Example: - -```compile_fail,E0371 -trait Foo { fn foo(&self) { } } -trait Bar: Foo { } -trait Baz: Bar { } - -impl Bar for Baz { } // error, `Baz` implements `Bar` by definition -impl Foo for Baz { } // error, `Baz` implements `Bar` which implements `Foo` -impl Baz for Baz { } // error, `Baz` (trivially) implements `Baz` -impl Baz for Bar { } // Note: This is OK -``` -"##, - -E0374: r##" -A struct without a field containing an unsized type cannot implement -`CoerceUnsized`. An [unsized type][1] is any type that the compiler -doesn't know the length or alignment of at compile time. Any struct -containing an unsized type is also unsized. - -[1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait - -Example of erroneous code: - -```compile_fail,E0374 -#![feature(coerce_unsized)] -use std::ops::CoerceUnsized; - -struct Foo<T: ?Sized> { - a: i32, -} - -// error: Struct `Foo` has no unsized fields that need `CoerceUnsized`. -impl<T, U> CoerceUnsized<Foo<U>> for Foo<T> - where T: CoerceUnsized<U> {} -``` - -`CoerceUnsized` is used to coerce one struct containing an unsized type -into another struct containing a different unsized type. If the struct -doesn't have any fields of unsized types then you don't need explicit -coercion to get the types you want. To fix this you can either -not try to implement `CoerceUnsized` or you can add a field that is -unsized to the struct. - -Example: - -``` -#![feature(coerce_unsized)] -use std::ops::CoerceUnsized; - -// We don't need to impl `CoerceUnsized` here. -struct Foo { - a: i32, -} - -// We add the unsized type field to the struct. -struct Bar<T: ?Sized> { - a: i32, - b: T, -} - -// The struct has an unsized field so we can implement -// `CoerceUnsized` for it. -impl<T, U> CoerceUnsized<Bar<U>> for Bar<T> - where T: CoerceUnsized<U> {} -``` - -Note that `CoerceUnsized` is mainly used by smart pointers like `Box`, `Rc` -and `Arc` to be able to mark that they can coerce unsized types that they -are pointing at. -"##, - -E0375: r##" -A struct with more than one field containing an unsized type cannot implement -`CoerceUnsized`. This only occurs when you are trying to coerce one of the -types in your struct to another type in the struct. In this case we try to -impl `CoerceUnsized` from `T` to `U` which are both types that the struct -takes. An [unsized type][1] is any type that the compiler doesn't know the -length or alignment of at compile time. Any struct containing an unsized type -is also unsized. - -Example of erroneous code: - -```compile_fail,E0375 -#![feature(coerce_unsized)] -use std::ops::CoerceUnsized; - -struct Foo<T: ?Sized, U: ?Sized> { - a: i32, - b: T, - c: U, -} - -// error: Struct `Foo` has more than one unsized field. -impl<T, U> CoerceUnsized<Foo<U, T>> for Foo<T, U> {} -``` - -`CoerceUnsized` only allows for coercion from a structure with a single -unsized type field to another struct with a single unsized type field. -In fact Rust only allows for a struct to have one unsized type in a struct -and that unsized type must be the last field in the struct. So having two -unsized types in a single struct is not allowed by the compiler. To fix this -use only one field containing an unsized type in the struct and then use -multiple structs to manage each unsized type field you need. - -Example: - -``` -#![feature(coerce_unsized)] -use std::ops::CoerceUnsized; - -struct Foo<T: ?Sized> { - a: i32, - b: T, -} - -impl <T, U> CoerceUnsized<Foo<U>> for Foo<T> - where T: CoerceUnsized<U> {} - -fn coerce_foo<T: CoerceUnsized<U>, U>(t: T) -> Foo<U> { - Foo { a: 12i32, b: t } // we use coercion to get the `Foo<U>` type we need -} -``` - -[1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait -"##, - -E0376: r##" -The type you are trying to impl `CoerceUnsized` for is not a struct. -`CoerceUnsized` can only be implemented for a struct. Unsized types are -already able to be coerced without an implementation of `CoerceUnsized` -whereas a struct containing an unsized type needs to know the unsized type -field it's containing is able to be coerced. An [unsized type][1] -is any type that the compiler doesn't know the length or alignment of at -compile time. Any struct containing an unsized type is also unsized. - -[1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait - -Example of erroneous code: - -```compile_fail,E0376 -#![feature(coerce_unsized)] -use std::ops::CoerceUnsized; - -struct Foo<T: ?Sized> { - a: T, -} - -// error: The type `U` is not a struct -impl<T, U> CoerceUnsized<U> for Foo<T> {} -``` - -The `CoerceUnsized` trait takes a struct type. Make sure the type you are -providing to `CoerceUnsized` is a struct with only the last field containing an -unsized type. - -Example: - -``` -#![feature(coerce_unsized)] -use std::ops::CoerceUnsized; - -struct Foo<T> { - a: T, -} - -// The `Foo<U>` is a struct so `CoerceUnsized` can be implemented -impl<T, U> CoerceUnsized<Foo<U>> for Foo<T> where T: CoerceUnsized<U> {} -``` - -Note that in Rust, structs can only contain an unsized type if the field -containing the unsized type is the last and only unsized type field in the -struct. -"##, - -E0378: r##" -The `DispatchFromDyn` trait currently can only be implemented for -builtin pointer types and structs that are newtype wrappers around them -— that is, the struct must have only one field (except for`PhantomData`), -and that field must itself implement `DispatchFromDyn`. - -Examples: - -``` -#![feature(dispatch_from_dyn, unsize)] -use std::{ - marker::Unsize, - ops::DispatchFromDyn, -}; - -struct Ptr<T: ?Sized>(*const T); - -impl<T: ?Sized, U: ?Sized> DispatchFromDyn<Ptr<U>> for Ptr<T> -where - T: Unsize<U>, -{} -``` - -``` -#![feature(dispatch_from_dyn)] -use std::{ - ops::DispatchFromDyn, - marker::PhantomData, -}; - -struct Wrapper<T> { - ptr: T, - _phantom: PhantomData<()>, -} - -impl<T, U> DispatchFromDyn<Wrapper<U>> for Wrapper<T> -where - T: DispatchFromDyn<U>, -{} -``` - -Example of illegal `DispatchFromDyn` implementation -(illegal because of extra field) - -```compile-fail,E0378 -#![feature(dispatch_from_dyn)] -use std::ops::DispatchFromDyn; - -struct WrapperExtraField<T> { - ptr: T, - extra_stuff: i32, -} - -impl<T, U> DispatchFromDyn<WrapperExtraField<U>> for WrapperExtraField<T> -where - T: DispatchFromDyn<U>, -{} -``` -"##, - -E0390: r##" -You tried to implement methods for a primitive type. Erroneous code example: - -```compile_fail,E0390 -struct Foo { - x: i32 -} - -impl *mut Foo {} -// error: only a single inherent implementation marked with -// `#[lang = "mut_ptr"]` is allowed for the `*mut T` primitive -``` - -This isn't allowed, but using a trait to implement a method is a good solution. -Example: - -``` -struct Foo { - x: i32 -} - -trait Bar { - fn bar(); -} - -impl Bar for *mut Foo { - fn bar() {} // ok! -} -``` -"##, - -E0392: r##" -This error indicates that a type or lifetime parameter has been declared -but not actually used. Here is an example that demonstrates the error: - -```compile_fail,E0392 -enum Foo<T> { - Bar, -} -``` - -If the type parameter was included by mistake, this error can be fixed -by simply removing the type parameter, as shown below: - -``` -enum Foo { - Bar, -} -``` - -Alternatively, if the type parameter was intentionally inserted, it must be -used. A simple fix is shown below: - -``` -enum Foo<T> { - Bar(T), -} -``` - -This error may also commonly be found when working with unsafe code. For -example, when using raw pointers one may wish to specify the lifetime for -which the pointed-at data is valid. An initial attempt (below) causes this -error: - -```compile_fail,E0392 -struct Foo<'a, T> { - x: *const T, -} -``` - -We want to express the constraint that Foo should not outlive `'a`, because -the data pointed to by `T` is only valid for that lifetime. The problem is -that there are no actual uses of `'a`. It's possible to work around this -by adding a PhantomData type to the struct, using it to tell the compiler -to act as if the struct contained a borrowed reference `&'a T`: - -``` -use std::marker::PhantomData; - -struct Foo<'a, T: 'a> { - x: *const T, - phantom: PhantomData<&'a T> -} -``` - -[PhantomData] can also be used to express information about unused type -parameters. - -[PhantomData]: https://doc.rust-lang.org/std/marker/struct.PhantomData.html -"##, - -E0393: r##" -A type parameter which references `Self` in its default value was not specified. -Example of erroneous code: - -```compile_fail,E0393 -trait A<T=Self> {} - -fn together_we_will_rule_the_galaxy(son: &A) {} -// error: the type parameter `T` must be explicitly specified in an -// object type because its default value `Self` references the -// type `Self` -``` - -A trait object is defined over a single, fully-defined trait. With a regular -default parameter, this parameter can just be substituted in. However, if the -default parameter is `Self`, the trait changes for each concrete type; i.e. -`i32` will be expected to implement `A<i32>`, `bool` will be expected to -implement `A<bool>`, etc... These types will not share an implementation of a -fully-defined trait; instead they share implementations of a trait with -different parameters substituted in for each implementation. This is -irreconcilable with what we need to make a trait object work, and is thus -disallowed. Making the trait concrete by explicitly specifying the value of the -defaulted parameter will fix this issue. Fixed example: - -``` -trait A<T=Self> {} - -fn together_we_will_rule_the_galaxy(son: &A<i32>) {} // Ok! -``` -"##, - -E0399: r##" -You implemented a trait, overriding one or more of its associated types but did -not reimplement its default methods. - -Example of erroneous code: - -```compile_fail,E0399 -#![feature(associated_type_defaults)] - -pub trait Foo { - type Assoc = u8; - fn bar(&self) {} -} - -impl Foo for i32 { - // error - the following trait items need to be reimplemented as - // `Assoc` was overridden: `bar` - type Assoc = i32; -} -``` - -To fix this, add an implementation for each default method from the trait: - -``` -#![feature(associated_type_defaults)] - -pub trait Foo { - type Assoc = u8; - fn bar(&self) {} -} - -impl Foo for i32 { - type Assoc = i32; - fn bar(&self) {} // ok! -} -``` -"##, - -E0436: r##" -The functional record update syntax is only allowed for structs. (Struct-like -enum variants don't qualify, for example.) - -Erroneous code example: - -```compile_fail,E0436 -enum PublicationFrequency { - Weekly, - SemiMonthly { days: (u8, u8), annual_special: bool }, -} - -fn one_up_competitor(competitor_frequency: PublicationFrequency) - -> PublicationFrequency { - match competitor_frequency { - PublicationFrequency::Weekly => PublicationFrequency::SemiMonthly { - days: (1, 15), annual_special: false - }, - c @ PublicationFrequency::SemiMonthly{ .. } => - PublicationFrequency::SemiMonthly { - annual_special: true, ..c // error: functional record update - // syntax requires a struct - } - } -} -``` - -Rewrite the expression without functional record update syntax: - -``` -enum PublicationFrequency { - Weekly, - SemiMonthly { days: (u8, u8), annual_special: bool }, -} - -fn one_up_competitor(competitor_frequency: PublicationFrequency) - -> PublicationFrequency { - match competitor_frequency { - PublicationFrequency::Weekly => PublicationFrequency::SemiMonthly { - days: (1, 15), annual_special: false - }, - PublicationFrequency::SemiMonthly{ days, .. } => - PublicationFrequency::SemiMonthly { - days, annual_special: true // ok! - } - } -} -``` -"##, - -E0439: r##" -The length of the platform-intrinsic function `simd_shuffle` -wasn't specified. Erroneous code example: - -```compile_fail,E0439 -#![feature(platform_intrinsics)] - -extern "platform-intrinsic" { - fn simd_shuffle<A,B>(a: A, b: A, c: [u32; 8]) -> B; - // error: invalid `simd_shuffle`, needs length: `simd_shuffle` -} -``` - -The `simd_shuffle` function needs the length of the array passed as -last parameter in its name. Example: - -``` -#![feature(platform_intrinsics)] - -extern "platform-intrinsic" { - fn simd_shuffle8<A,B>(a: A, b: A, c: [u32; 8]) -> B; -} -``` -"##, - -E0516: r##" -The `typeof` keyword is currently reserved but unimplemented. -Erroneous code example: - -```compile_fail,E0516 -fn main() { - let x: typeof(92) = 92; -} -``` - -Try using type inference instead. Example: - -``` -fn main() { - let x = 92; -} -``` -"##, - -E0520: r##" -A non-default implementation was already made on this type so it cannot be -specialized further. Erroneous code example: - -```compile_fail,E0520 -#![feature(specialization)] - -trait SpaceLlama { - fn fly(&self); -} - -// applies to all T -impl<T> SpaceLlama for T { - default fn fly(&self) {} -} - -// non-default impl -// applies to all `Clone` T and overrides the previous impl -impl<T: Clone> SpaceLlama for T { - fn fly(&self) {} -} - -// since `i32` is clone, this conflicts with the previous implementation -impl SpaceLlama for i32 { - default fn fly(&self) {} - // error: item `fly` is provided by an `impl` that specializes - // another, but the item in the parent `impl` is not marked - // `default` and so it cannot be specialized. -} -``` - -Specialization only allows you to override `default` functions in -implementations. - -To fix this error, you need to mark all the parent implementations as default. -Example: - -``` -#![feature(specialization)] - -trait SpaceLlama { - fn fly(&self); -} - -// applies to all T -impl<T> SpaceLlama for T { - default fn fly(&self) {} // This is a parent implementation. -} - -// applies to all `Clone` T; overrides the previous impl -impl<T: Clone> SpaceLlama for T { - default fn fly(&self) {} // This is a parent implementation but was - // previously not a default one, causing the error -} - -// applies to i32, overrides the previous two impls -impl SpaceLlama for i32 { - fn fly(&self) {} // And now that's ok! -} -``` -"##, - -E0527: r##" -The number of elements in an array or slice pattern differed from the number of -elements in the array being matched. - -Example of erroneous code: - -```compile_fail,E0527 -let r = &[1, 2, 3, 4]; -match r { - &[a, b] => { // error: pattern requires 2 elements but array - // has 4 - println!("a={}, b={}", a, b); - } -} -``` - -Ensure that the pattern is consistent with the size of the matched -array. Additional elements can be matched with `..`: - -``` -#![feature(slice_patterns)] - -let r = &[1, 2, 3, 4]; -match r { - &[a, b, ..] => { // ok! - println!("a={}, b={}", a, b); - } -} -``` -"##, - -E0528: r##" -An array or slice pattern required more elements than were present in the -matched array. - -Example of erroneous code: - -```compile_fail,E0528 -#![feature(slice_patterns)] - -let r = &[1, 2]; -match r { - &[a, b, c, rest @ ..] => { // error: pattern requires at least 3 - // elements but array has 2 - println!("a={}, b={}, c={} rest={:?}", a, b, c, rest); - } -} -``` - -Ensure that the matched array has at least as many elements as the pattern -requires. You can match an arbitrary number of remaining elements with `..`: - -``` -#![feature(slice_patterns)] - -let r = &[1, 2, 3, 4, 5]; -match r { - &[a, b, c, rest @ ..] => { // ok! - // prints `a=1, b=2, c=3 rest=[4, 5]` - println!("a={}, b={}, c={} rest={:?}", a, b, c, rest); - } -} -``` -"##, - -E0529: r##" -An array or slice pattern was matched against some other type. - -Example of erroneous code: - -```compile_fail,E0529 -let r: f32 = 1.0; -match r { - [a, b] => { // error: expected an array or slice, found `f32` - println!("a={}, b={}", a, b); - } -} -``` - -Ensure that the pattern and the expression being matched on are of consistent -types: - -``` -let r = [1.0, 2.0]; -match r { - [a, b] => { // ok! - println!("a={}, b={}", a, b); - } -} -``` -"##, - -E0533: r##" -An item which isn't a unit struct, a variant, nor a constant has been used as a -match pattern. - -Erroneous code example: - -```compile_fail,E0533 -struct Tortoise; - -impl Tortoise { - fn turtle(&self) -> u32 { 0 } -} - -match 0u32 { - Tortoise::turtle => {} // Error! - _ => {} -} -if let Tortoise::turtle = 0u32 {} // Same error! -``` - -If you want to match against a value returned by a method, you need to bind the -value first: - -``` -struct Tortoise; - -impl Tortoise { - fn turtle(&self) -> u32 { 0 } -} - -match 0u32 { - x if x == Tortoise.turtle() => {} // Bound into `x` then we compare it! - _ => {} -} -``` -"##, - -E0534: r##" -The `inline` attribute was malformed. - -Erroneous code example: - -```ignore (compile_fail not working here; see Issue #43707) -#[inline()] // error: expected one argument -pub fn something() {} - -fn main() {} -``` - -The parenthesized `inline` attribute requires the parameter to be specified: - -``` -#[inline(always)] -fn something() {} -``` - -or: - -``` -#[inline(never)] -fn something() {} -``` - -Alternatively, a paren-less version of the attribute may be used to hint the -compiler about inlining opportunity: - -``` -#[inline] -fn something() {} -``` - -For more information about the inline attribute, read: -https://doc.rust-lang.org/reference.html#inline-attributes -"##, - -E0535: r##" -An unknown argument was given to the `inline` attribute. - -Erroneous code example: - -```ignore (compile_fail not working here; see Issue #43707) -#[inline(unknown)] // error: invalid argument -pub fn something() {} - -fn main() {} -``` - -The `inline` attribute only supports two arguments: - - * always - * never - -All other arguments given to the `inline` attribute will return this error. -Example: - -``` -#[inline(never)] // ok! -pub fn something() {} - -fn main() {} -``` - -For more information about the inline attribute, https: -read://doc.rust-lang.org/reference.html#inline-attributes -"##, - -E0559: r##" -An unknown field was specified into an enum's structure variant. - -Erroneous code example: - -```compile_fail,E0559 -enum Field { - Fool { x: u32 }, -} - -let s = Field::Fool { joke: 0 }; -// error: struct variant `Field::Fool` has no field named `joke` -``` - -Verify you didn't misspell the field's name or that the field exists. Example: - -``` -enum Field { - Fool { joke: u32 }, -} - -let s = Field::Fool { joke: 0 }; // ok! -``` -"##, - -E0560: r##" -An unknown field was specified into a structure. - -Erroneous code example: - -```compile_fail,E0560 -struct Simba { - mother: u32, -} - -let s = Simba { mother: 1, father: 0 }; -// error: structure `Simba` has no field named `father` -``` - -Verify you didn't misspell the field's name or that the field exists. Example: - -``` -struct Simba { - mother: u32, - father: u32, -} - -let s = Simba { mother: 1, father: 0 }; // ok! -``` -"##, - -E0569: r##" -If an impl has a generic parameter with the `#[may_dangle]` attribute, then -that impl must be declared as an `unsafe impl. - -Erroneous code example: - -```compile_fail,E0569 -#![feature(dropck_eyepatch)] - -struct Foo<X>(X); -impl<#[may_dangle] X> Drop for Foo<X> { - fn drop(&mut self) { } -} -``` - -In this example, we are asserting that the destructor for `Foo` will not -access any data of type `X`, and require this assertion to be true for -overall safety in our program. The compiler does not currently attempt to -verify this assertion; therefore we must tag this `impl` as unsafe. -"##, - -E0570: r##" -The requested ABI is unsupported by the current target. - -The rust compiler maintains for each target a blacklist of ABIs unsupported on -that target. If an ABI is present in such a list this usually means that the -target / ABI combination is currently unsupported by llvm. - -If necessary, you can circumvent this check using custom target specifications. -"##, - -E0572: r##" -A return statement was found outside of a function body. - -Erroneous code example: - -```compile_fail,E0572 -const FOO: u32 = return 0; // error: return statement outside of function body - -fn main() {} -``` - -To fix this issue, just remove the return keyword or move the expression into a -function. Example: - -``` -const FOO: u32 = 0; - -fn some_fn() -> u32 { - return FOO; -} - -fn main() { - some_fn(); -} -``` -"##, - -E0581: r##" -In a `fn` type, a lifetime appears only in the return type, -and not in the arguments types. - -Erroneous code example: - -```compile_fail,E0581 -fn main() { - // Here, `'a` appears only in the return type: - let x: for<'a> fn() -> &'a i32; -} -``` - -To fix this issue, either use the lifetime in the arguments, or use -`'static`. Example: - -``` -fn main() { - // Here, `'a` appears only in the return type: - let x: for<'a> fn(&'a i32) -> &'a i32; - let y: fn() -> &'static i32; -} -``` - -Note: The examples above used to be (erroneously) accepted by the -compiler, but this was since corrected. See [issue #33685] for more -details. - -[issue #33685]: https://github.com/rust-lang/rust/issues/33685 -"##, - -E0582: r##" -A lifetime appears only in an associated-type binding, -and not in the input types to the trait. - -Erroneous code example: - -```compile_fail,E0582 -fn bar<F>(t: F) - // No type can satisfy this requirement, since `'a` does not - // appear in any of the input types (here, `i32`): - where F: for<'a> Fn(i32) -> Option<&'a i32> -{ -} - -fn main() { } -``` - -To fix this issue, either use the lifetime in the inputs, or use -`'static`. Example: - -``` -fn bar<F, G>(t: F, u: G) - where F: for<'a> Fn(&'a i32) -> Option<&'a i32>, - G: Fn(i32) -> Option<&'static i32>, -{ -} - -fn main() { } -``` - -Note: The examples above used to be (erroneously) accepted by the -compiler, but this was since corrected. See [issue #33685] for more -details. - -[issue #33685]: https://github.com/rust-lang/rust/issues/33685 -"##, - -E0587: r##" -A type has both `packed` and `align` representation hints. - -Erroneous code example: - -```compile_fail,E0587 -#[repr(packed, align(8))] // error! -struct Umbrella(i32); -``` - -You cannot use `packed` and `align` hints on a same type. If you want to pack a -type to a given size, you should provide a size to packed: - -``` -#[repr(packed)] // ok! -struct Umbrella(i32); -``` -"##, - -E0588: r##" -A type with `packed` representation hint has a field with `align` -representation hint. - -Erroneous code example: - -```compile_fail,E0588 -#[repr(align(16))] -struct Aligned(i32); - -#[repr(packed)] // error! -struct Packed(Aligned); -``` - -Just like you cannot have both `align` and `packed` representation hints on a -same type, a `packed` type cannot contain another type with the `align` -representation hint. However, you can do the opposite: - -``` -#[repr(packed)] -struct Packed(i32); - -#[repr(align(16))] // ok! -struct Aligned(Packed); -``` -"##, - -E0592: r##" -This error occurs when you defined methods or associated functions with same -name. - -Erroneous code example: - -```compile_fail,E0592 -struct Foo; - -impl Foo { - fn bar() {} // previous definition here -} - -impl Foo { - fn bar() {} // duplicate definition here -} -``` - -A similar error is E0201. The difference is whether there is one declaration -block or not. To avoid this error, you must give each `fn` a unique name. - -``` -struct Foo; - -impl Foo { - fn bar() {} -} - -impl Foo { - fn baz() {} // define with different name -} -``` -"##, - -E0599: r##" -This error occurs when a method is used on a type which doesn't implement it: - -Erroneous code example: - -```compile_fail,E0599 -struct Mouth; - -let x = Mouth; -x.chocolate(); // error: no method named `chocolate` found for type `Mouth` - // in the current scope -``` -"##, - -E0600: r##" -An unary operator was used on a type which doesn't implement it. - -Example of erroneous code: - -```compile_fail,E0600 -enum Question { - Yes, - No, -} - -!Question::Yes; // error: cannot apply unary operator `!` to type `Question` -``` - -In this case, `Question` would need to implement the `std::ops::Not` trait in -order to be able to use `!` on it. Let's implement it: - -``` -use std::ops::Not; - -enum Question { - Yes, - No, -} - -// We implement the `Not` trait on the enum. -impl Not for Question { - type Output = bool; - - fn not(self) -> bool { - match self { - Question::Yes => false, // If the `Answer` is `Yes`, then it - // returns false. - Question::No => true, // And here we do the opposite. - } - } -} - -assert_eq!(!Question::Yes, false); -assert_eq!(!Question::No, true); -``` -"##, - -E0608: r##" -An attempt to index into a type which doesn't implement the `std::ops::Index` -trait was performed. - -Erroneous code example: - -```compile_fail,E0608 -0u8[2]; // error: cannot index into a value of type `u8` -``` - -To be able to index into a type it needs to implement the `std::ops::Index` -trait. Example: - -``` -let v: Vec<u8> = vec![0, 1, 2, 3]; - -// The `Vec` type implements the `Index` trait so you can do: -println!("{}", v[2]); -``` -"##, - -E0604: r##" -A cast to `char` was attempted on a type other than `u8`. - -Erroneous code example: - -```compile_fail,E0604 -0u32 as char; // error: only `u8` can be cast as `char`, not `u32` -``` - -As the error message indicates, only `u8` can be cast into `char`. Example: - -``` -let c = 86u8 as char; // ok! -assert_eq!(c, 'V'); -``` - -For more information about casts, take a look at the Type cast section in -[The Reference Book][1]. - -[1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions -"##, - -E0605: r##" -An invalid cast was attempted. - -Erroneous code examples: - -```compile_fail,E0605 -let x = 0u8; -x as Vec<u8>; // error: non-primitive cast: `u8` as `std::vec::Vec<u8>` - -// Another example - -let v = core::ptr::null::<u8>(); // So here, `v` is a `*const u8`. -v as &u8; // error: non-primitive cast: `*const u8` as `&u8` -``` - -Only primitive types can be cast into each other. Examples: - -``` -let x = 0u8; -x as u32; // ok! - -let v = core::ptr::null::<u8>(); -v as *const i8; // ok! -``` - -For more information about casts, take a look at the Type cast section in -[The Reference Book][1]. - -[1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions -"##, - -E0606: r##" -An incompatible cast was attempted. - -Erroneous code example: - -```compile_fail,E0606 -let x = &0u8; // Here, `x` is a `&u8`. -let y: u32 = x as u32; // error: casting `&u8` as `u32` is invalid -``` - -When casting, keep in mind that only primitive types can be cast into each -other. Example: - -``` -let x = &0u8; -let y: u32 = *x as u32; // We dereference it first and then cast it. -``` - -For more information about casts, take a look at the Type cast section in -[The Reference Book][1]. - -[1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions -"##, - -E0607: r##" -A cast between a thin and a fat pointer was attempted. - -Erroneous code example: - -```compile_fail,E0607 -let v = core::ptr::null::<u8>(); -v as *const [u8]; -``` - -First: what are thin and fat pointers? - -Thin pointers are "simple" pointers: they are purely a reference to a memory -address. - -Fat pointers are pointers referencing Dynamically Sized Types (also called DST). -DST don't have a statically known size, therefore they can only exist behind -some kind of pointers that contain additional information. Slices and trait -objects are DSTs. In the case of slices, the additional information the fat -pointer holds is their size. - -To fix this error, don't try to cast directly between thin and fat pointers. - -For more information about casts, take a look at the Type cast section in -[The Reference Book][1]. - -[1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions -"##, - -E0609: r##" -Attempted to access a non-existent field in a struct. - -Erroneous code example: - -```compile_fail,E0609 -struct StructWithFields { - x: u32, -} - -let s = StructWithFields { x: 0 }; -println!("{}", s.foo); // error: no field `foo` on type `StructWithFields` -``` - -To fix this error, check that you didn't misspell the field's name or that the -field actually exists. Example: - -``` -struct StructWithFields { - x: u32, -} - -let s = StructWithFields { x: 0 }; -println!("{}", s.x); // ok! -``` -"##, - -E0610: r##" -Attempted to access a field on a primitive type. - -Erroneous code example: - -```compile_fail,E0610 -let x: u32 = 0; -println!("{}", x.foo); // error: `{integer}` is a primitive type, therefore - // doesn't have fields -``` - -Primitive types are the most basic types available in Rust and don't have -fields. To access data via named fields, struct types are used. Example: - -``` -// We declare struct called `Foo` containing two fields: -struct Foo { - x: u32, - y: i64, -} - -// We create an instance of this struct: -let variable = Foo { x: 0, y: -12 }; -// And we can now access its fields: -println!("x: {}, y: {}", variable.x, variable.y); -``` - -For more information about primitives and structs, take a look at The Book: -https://doc.rust-lang.org/book/ch03-02-data-types.html -https://doc.rust-lang.org/book/ch05-00-structs.html -"##, - -E0614: r##" -Attempted to dereference a variable which cannot be dereferenced. - -Erroneous code example: - -```compile_fail,E0614 -let y = 0u32; -*y; // error: type `u32` cannot be dereferenced -``` - -Only types implementing `std::ops::Deref` can be dereferenced (such as `&T`). -Example: - -``` -let y = 0u32; -let x = &y; -// So here, `x` is a `&u32`, so we can dereference it: -*x; // ok! -``` -"##, - -E0615: r##" -Attempted to access a method like a field. - -Erroneous code example: - -```compile_fail,E0615 -struct Foo { - x: u32, -} - -impl Foo { - fn method(&self) {} -} - -let f = Foo { x: 0 }; -f.method; // error: attempted to take value of method `method` on type `Foo` -``` - -If you want to use a method, add `()` after it: - -``` -# struct Foo { x: u32 } -# impl Foo { fn method(&self) {} } -# let f = Foo { x: 0 }; -f.method(); -``` - -However, if you wanted to access a field of a struct check that the field name -is spelled correctly. Example: - -``` -# struct Foo { x: u32 } -# impl Foo { fn method(&self) {} } -# let f = Foo { x: 0 }; -println!("{}", f.x); -``` -"##, - -E0616: r##" -Attempted to access a private field on a struct. - -Erroneous code example: - -```compile_fail,E0616 -mod some_module { - pub struct Foo { - x: u32, // So `x` is private in here. - } - - impl Foo { - pub fn new() -> Foo { Foo { x: 0 } } - } -} - -let f = some_module::Foo::new(); -println!("{}", f.x); // error: field `x` of struct `some_module::Foo` is private -``` - -If you want to access this field, you have two options: - -1) Set the field public: - -``` -mod some_module { - pub struct Foo { - pub x: u32, // `x` is now public. - } - - impl Foo { - pub fn new() -> Foo { Foo { x: 0 } } - } -} - -let f = some_module::Foo::new(); -println!("{}", f.x); // ok! -``` - -2) Add a getter function: - -``` -mod some_module { - pub struct Foo { - x: u32, // So `x` is still private in here. - } - - impl Foo { - pub fn new() -> Foo { Foo { x: 0 } } - - // We create the getter function here: - pub fn get_x(&self) -> &u32 { &self.x } - } -} - -let f = some_module::Foo::new(); -println!("{}", f.get_x()); // ok! -``` -"##, - -E0617: r##" -Attempted to pass an invalid type of variable into a variadic function. - -Erroneous code example: - -```compile_fail,E0617 -extern { - fn printf(c: *const i8, ...); -} - -unsafe { - printf(::std::ptr::null(), 0f32); - // error: cannot pass an `f32` to variadic function, cast to `c_double` -} -``` - -Certain Rust types must be cast before passing them to a variadic function, -because of arcane ABI rules dictated by the C standard. To fix the error, -cast the value to the type specified by the error message (which you may need -to import from `std::os::raw`). -"##, - -E0618: r##" -Attempted to call something which isn't a function nor a method. - -Erroneous code examples: - -```compile_fail,E0618 -enum X { - Entry, -} - -X::Entry(); // error: expected function, tuple struct or tuple variant, - // found `X::Entry` - -// Or even simpler: -let x = 0i32; -x(); // error: expected function, tuple struct or tuple variant, found `i32` -``` - -Only functions and methods can be called using `()`. Example: - -``` -// We declare a function: -fn i_am_a_function() {} - -// And we call it: -i_am_a_function(); -``` -"##, - -E0619: r##" -#### Note: this error code is no longer emitted by the compiler. -The type-checker needed to know the type of an expression, but that type had not -yet been inferred. - -Erroneous code example: - -```compile_fail -let mut x = vec![]; -match x.pop() { - Some(v) => { - // Here, the type of `v` is not (yet) known, so we - // cannot resolve this method call: - v.to_uppercase(); // error: the type of this value must be known in - // this context - } - None => {} -} -``` - -Type inference typically proceeds from the top of the function to the bottom, -figuring out types as it goes. In some cases -- notably method calls and -overloadable operators like `*` -- the type checker may not have enough -information *yet* to make progress. This can be true even if the rest of the -function provides enough context (because the type-checker hasn't looked that -far ahead yet). In this case, type annotations can be used to help it along. - -To fix this error, just specify the type of the variable. Example: - -``` -let mut x: Vec<String> = vec![]; // We precise the type of the vec elements. -match x.pop() { - Some(v) => { - v.to_uppercase(); // Since rustc now knows the type of the vec elements, - // we can use `v`'s methods. - } - None => {} -} -``` -"##, - -E0620: r##" -A cast to an unsized type was attempted. - -Erroneous code example: - -```compile_fail,E0620 -let x = &[1_usize, 2] as [usize]; // error: cast to unsized type: `&[usize; 2]` - // as `[usize]` -``` - -In Rust, some types don't have a known size at compile-time. For example, in a -slice type like `[u32]`, the number of elements is not known at compile-time and -hence the overall size cannot be computed. As a result, such types can only be -manipulated through a reference (e.g., `&T` or `&mut T`) or other pointer-type -(e.g., `Box` or `Rc`). Try casting to a reference instead: - -``` -let x = &[1_usize, 2] as &[usize]; // ok! -``` -"##, - -E0622: r##" -An intrinsic was declared without being a function. - -Erroneous code example: - -```compile_fail,E0622 -#![feature(intrinsics)] -extern "rust-intrinsic" { - pub static breakpoint : unsafe extern "rust-intrinsic" fn(); - // error: intrinsic must be a function -} - -fn main() { unsafe { breakpoint(); } } -``` - -An intrinsic is a function available for use in a given programming language -whose implementation is handled specially by the compiler. In order to fix this -error, just declare a function. -"##, - -E0624: r##" -A private item was used outside of its scope. - -Erroneous code example: - -```compile_fail,E0624 -mod inner { - pub struct Foo; - - impl Foo { - fn method(&self) {} - } -} - -let foo = inner::Foo; -foo.method(); // error: method `method` is private -``` - -Two possibilities are available to solve this issue: - -1. Only use the item in the scope it has been defined: - -``` -mod inner { - pub struct Foo; - - impl Foo { - fn method(&self) {} - } - - pub fn call_method(foo: &Foo) { // We create a public function. - foo.method(); // Which calls the item. - } -} - -let foo = inner::Foo; -inner::call_method(&foo); // And since the function is public, we can call the - // method through it. -``` - -2. Make the item public: - -``` -mod inner { - pub struct Foo; - - impl Foo { - pub fn method(&self) {} // It's now public. - } -} - -let foo = inner::Foo; -foo.method(); // Ok! -``` -"##, - -E0638: r##" -This error indicates that the struct, enum or enum variant must be matched -non-exhaustively as it has been marked as `non_exhaustive`. - -When applied within a crate, downstream users of the crate will need to use the -`_` pattern when matching enums and use the `..` pattern when matching structs. -Downstream crates cannot match against non-exhaustive enum variants. - -For example, in the below example, since the enum is marked as -`non_exhaustive`, it is required that downstream crates match non-exhaustively -on it. - -```rust,ignore (pseudo-Rust) -use std::error::Error as StdError; - -#[non_exhaustive] pub enum Error { - Message(String), - Other, -} - -impl StdError for Error { - fn description(&self) -> &str { - // This will not error, despite being marked as non_exhaustive, as this - // enum is defined within the current crate, it can be matched - // exhaustively. - match *self { - Message(ref s) => s, - Other => "other or unknown error", - } - } -} -``` - -An example of matching non-exhaustively on the above enum is provided below: - -```rust,ignore (pseudo-Rust) -use mycrate::Error; - -// This will not error as the non_exhaustive Error enum has been matched with a -// wildcard. -match error { - Message(ref s) => ..., - Other => ..., - _ => ..., -} -``` - -Similarly, for structs, match with `..` to avoid this error. -"##, - -E0639: r##" -This error indicates that the struct, enum or enum variant cannot be -instantiated from outside of the defining crate as it has been marked -as `non_exhaustive` and as such more fields/variants may be added in -future that could cause adverse side effects for this code. - -It is recommended that you look for a `new` function or equivalent in the -crate's documentation. -"##, - -E0643: r##" -This error indicates that there is a mismatch between generic parameters and -impl Trait parameters in a trait declaration versus its impl. - -```compile_fail,E0643 -trait Foo { - fn foo(&self, _: &impl Iterator); -} -impl Foo for () { - fn foo<U: Iterator>(&self, _: &U) { } // error method `foo` has incompatible - // signature for trait -} -``` -"##, - -E0646: r##" -It is not possible to define `main` with a where clause. -Erroneous code example: - -```compile_fail,E0646 -fn main() where i32: Copy { // error: main function is not allowed to have - // a where clause -} -``` -"##, - -E0647: r##" -It is not possible to define `start` with a where clause. -Erroneous code example: - -```compile_fail,E0647 -#![feature(start)] - -#[start] -fn start(_: isize, _: *const *const u8) -> isize where (): Copy { - //^ error: start function is not allowed to have a where clause - 0 -} -``` -"##, - -E0648: r##" -`export_name` attributes may not contain null characters (`\0`). - -```compile_fail,E0648 -#[export_name="\0foo"] // error: `export_name` may not contain null characters -pub fn bar() {} -``` -"##, - -E0689: r##" -This error indicates that the numeric value for the method being passed exists -but the type of the numeric value or binding could not be identified. - -The error happens on numeric literals: - -```compile_fail,E0689 -2.0.neg(); -``` - -and on numeric bindings without an identified concrete type: - -```compile_fail,E0689 -let x = 2.0; -x.neg(); // same error as above -``` - -Because of this, you must give the numeric literal or binding a type: - -``` -use std::ops::Neg; - -let _ = 2.0_f32.neg(); -let x: f32 = 2.0; -let _ = x.neg(); -let _ = (2.0 as f32).neg(); -``` -"##, - -E0690: r##" -A struct with the representation hint `repr(transparent)` had zero or more than -one fields that were not guaranteed to be zero-sized. - -Erroneous code example: - -```compile_fail,E0690 -#[repr(transparent)] -struct LengthWithUnit<U> { // error: transparent struct needs exactly one - value: f32, // non-zero-sized field, but has 2 - unit: U, -} -``` - -Because transparent structs are represented exactly like one of their fields at -run time, said field must be uniquely determined. If there is no field, or if -there are multiple fields, it is not clear how the struct should be represented. -Note that fields of zero-typed types (e.g., `PhantomData`) can also exist -alongside the field that contains the actual data, they do not count for this -error. When generic types are involved (as in the above example), an error is -reported because the type parameter could be non-zero-sized. - -To combine `repr(transparent)` with type parameters, `PhantomData` may be -useful: - -``` -use std::marker::PhantomData; - -#[repr(transparent)] -struct LengthWithUnit<U> { - value: f32, - unit: PhantomData<U>, -} -``` -"##, - -E0691: r##" -A struct, enum, or union with the `repr(transparent)` representation hint -contains a zero-sized field that requires non-trivial alignment. - -Erroneous code example: - -```compile_fail,E0691 -#![feature(repr_align)] - -#[repr(align(32))] -struct ForceAlign32; - -#[repr(transparent)] -struct Wrapper(f32, ForceAlign32); // error: zero-sized field in transparent - // struct has alignment larger than 1 -``` - -A transparent struct, enum, or union is supposed to be represented exactly like -the piece of data it contains. Zero-sized fields with different alignment -requirements potentially conflict with this property. In the example above, -`Wrapper` would have to be aligned to 32 bytes even though `f32` has a smaller -alignment requirement. - -Consider removing the over-aligned zero-sized field: - -``` -#[repr(transparent)] -struct Wrapper(f32); -``` - -Alternatively, `PhantomData<T>` has alignment 1 for all `T`, so you can use it -if you need to keep the field for some reason: - -``` -#![feature(repr_align)] - -use std::marker::PhantomData; - -#[repr(align(32))] -struct ForceAlign32; - -#[repr(transparent)] -struct Wrapper(f32, PhantomData<ForceAlign32>); -``` - -Note that empty arrays `[T; 0]` have the same alignment requirement as the -element type `T`. Also note that the error is conservatively reported even when -the alignment of the zero-sized type is less than or equal to the data field's -alignment. -"##, - -E0699: r##" -A method was called on a raw pointer whose inner type wasn't completely known. - -For example, you may have done something like: - -```compile_fail -# #![deny(warnings)] -let foo = &1; -let bar = foo as *const _; -if bar.is_null() { - // ... -} -``` - -Here, the type of `bar` isn't known; it could be a pointer to anything. Instead, -specify a type for the pointer (preferably something that makes sense for the -thing you're pointing to): - -``` -let foo = &1; -let bar = foo as *const i32; -if bar.is_null() { - // ... -} -``` - -Even though `is_null()` exists as a method on any raw pointer, Rust shows this -error because Rust allows for `self` to have arbitrary types (behind the -arbitrary_self_types feature flag). - -This means that someone can specify such a function: - -```ignore (cannot-doctest-feature-doesnt-exist-yet) -impl Foo { - fn is_null(self: *const Self) -> bool { - // do something else - } -} -``` - -and now when you call `.is_null()` on a raw pointer to `Foo`, there's ambiguity. - -Given that we don't know what type the pointer is, and there's potential -ambiguity for some types, we disallow calling methods on raw pointers when -the type is unknown. -"##, - -E0714: r##" -A `#[marker]` trait contained an associated item. - -The items of marker traits cannot be overridden, so there's no need to have them -when they cannot be changed per-type anyway. If you wanted them for ergonomic -reasons, consider making an extension trait instead. -"##, - -E0715: r##" -An `impl` for a `#[marker]` trait tried to override an associated item. - -Because marker traits are allowed to have multiple implementations for the same -type, it's not allowed to override anything in those implementations, as it -would be ambiguous which override should actually be used. -"##, - - -E0720: r##" -An `impl Trait` type expands to a recursive type. - -An `impl Trait` type must be expandable to a concrete type that contains no -`impl Trait` types. For example the following example tries to create an -`impl Trait` type `T` that is equal to `[T, T]`: - -```compile_fail,E0720 -fn make_recursive_type() -> impl Sized { - [make_recursive_type(), make_recursive_type()] -} -``` -"##, - -E0730: r##" -An array without a fixed length was pattern-matched. - -Example of erroneous code: - -```compile_fail,E0730 -#![feature(const_generics)] - -fn is_123<const N: usize>(x: [u32; N]) -> bool { - match x { - [1, 2, 3] => true, // error: cannot pattern-match on an - // array without a fixed length - _ => false - } -} -``` - -Ensure that the pattern is consistent with the size of the matched -array. Additional elements can be matched with `..`: - -``` -#![feature(slice_patterns)] - -let r = &[1, 2, 3, 4]; -match r { - &[a, b, ..] => { // ok! - println!("a={}, b={}", a, b); - } -} -``` -"##, - -E0731: r##" -An enum with the representation hint `repr(transparent)` had zero or more than -one variants. - -Erroneous code example: - -```compile_fail,E0731 -#[repr(transparent)] -enum Status { // error: transparent enum needs exactly one variant, but has 2 - Errno(u32), - Ok, -} -``` - -Because transparent enums are represented exactly like one of their variants at -run time, said variant must be uniquely determined. If there is no variant, or -if there are multiple variants, it is not clear how the enum should be -represented. -"##, - -E0732: r##" -An `enum` with a discriminant must specify a `#[repr(inttype)]`. - -A `#[repr(inttype)]` must be provided on an `enum` if it has a non-unit -variant with a discriminant, or where there are both unit variants with -discriminants and non-unit variants. This restriction ensures that there -is a well-defined way to extract a variant's discriminant from a value; -for instance: - -``` -#![feature(arbitrary_enum_discriminant)] - -#[repr(u8)] -enum Enum { - Unit = 3, - Tuple(u16) = 2, - Struct { - a: u8, - b: u16, - } = 1, -} - -fn discriminant(v : &Enum) -> u8 { - unsafe { *(v as *const Enum as *const u8) } -} - -assert_eq!(3, discriminant(&Enum::Unit)); -assert_eq!(2, discriminant(&Enum::Tuple(5))); -assert_eq!(1, discriminant(&Enum::Struct{a: 7, b: 11})); -``` -"##, - -E0740: r##" -A `union` cannot have fields with destructors. -"##, - -E0733: r##" -Recursion in an `async fn` requires boxing. For example, this will not compile: - -```edition2018,compile_fail,E0733 -async fn foo(n: usize) { - if n > 0 { - foo(n - 1).await; - } -} -``` - -To achieve async recursion, the `async fn` needs to be desugared -such that the `Future` is explicit in the return type: - -```edition2018,compile_fail,E0720 -use std::future::Future; -fn foo_desugared(n: usize) -> impl Future<Output = ()> { - async move { - if n > 0 { - foo_desugared(n - 1).await; - } - } -} -``` - -Finally, the future is wrapped in a pinned box: - -```edition2018 -use std::future::Future; -use std::pin::Pin; -fn foo_recursive(n: usize) -> Pin<Box<dyn Future<Output = ()>>> { - Box::pin(async move { - if n > 0 { - foo_recursive(n - 1).await; - } - }) -} -``` - -The `Box<...>` ensures that the result is of known size, -and the pin is required to keep it in the same place in memory. -"##, - -E0737: r##" -`#[track_caller]` requires functions to have the `"Rust"` ABI for implicitly -receiving caller location. See [RFC 2091] for details on this and other -restrictions. - -Erroneous code example: - -```compile_fail,E0737 -#![feature(track_caller)] - -#[track_caller] -extern "C" fn foo() {} -``` - -[RFC 2091]: https://github.com/rust-lang/rfcs/blob/master/text/2091-inline-semantic.md -"##, - -E0741: r##" -Only `structural_match` types (that is, types that derive `PartialEq` and `Eq`) -may be used as the types of const generic parameters. - -```compile_fail,E0741 -#![feature(const_generics)] - -struct A; - -struct B<const X: A>; // error! -``` - -To fix this example, we derive `PartialEq` and `Eq`. - -``` -#![feature(const_generics)] - -#[derive(PartialEq, Eq)] -struct A; - -struct B<const X: A>; // ok! -``` -"##, - -; -// E0035, merged into E0087/E0089 -// E0036, merged into E0087/E0089 -// E0068, -// E0085, -// E0086, -// E0103, -// E0104, -// E0122, // bounds in type aliases are ignored, turned into proper lint -// E0123, -// E0127, -// E0129, -// E0141, -// E0159, // use of trait `{}` as struct constructor -// E0163, // merged into E0071 -// E0167, -// E0168, -// E0172, // non-trait found in a type sum, moved to resolve -// E0173, // manual implementations of unboxed closure traits are experimental -// E0174, -// E0182, // merged into E0229 - E0183, -// E0187, // cannot infer the kind of the closure -// E0188, // can not cast an immutable reference to a mutable pointer -// E0189, // deprecated: can only cast a boxed pointer to a boxed object -// E0190, // deprecated: can only cast a &-pointer to an &-object -// E0194, // merged into E0403 -// E0196, // cannot determine a type for this closure - E0203, // type parameter has more than one relaxed default bound, - // and only one is supported - E0208, -// E0209, // builtin traits can only be implemented on structs or enums - E0212, // cannot extract an associated type from a higher-ranked trait bound -// E0213, // associated types are not accepted in this context -// E0215, // angle-bracket notation is not stable with `Fn` -// E0216, // parenthetical notation is only stable with `Fn` -// E0217, // ambiguous associated type, defined in multiple supertraits -// E0218, // no associated type defined -// E0219, // associated type defined in higher-ranked supertrait -// E0222, // Error code E0045 (variadic function must have C or cdecl calling - // convention) duplicate - E0224, // at least one non-builtin train is required for an object type - E0227, // ambiguous lifetime bound, explicit lifetime bound required - E0228, // explicit lifetime bound required -// E0233, -// E0234, -// E0235, // structure constructor specifies a structure of type but -// E0236, // no lang item for range syntax -// E0237, // no lang item for range syntax -// E0238, // parenthesized parameters may only be used with a trait -// E0239, // `next` method of `Iterator` trait has unexpected type -// E0240, -// E0241, -// E0242, -// E0245, // not a trait -// E0246, // invalid recursive type -// E0247, -// E0248, // value used as a type, now reported earlier during resolution - // as E0412 -// E0249, -// E0319, // trait impls for defaulted traits allowed just for structs/enums -// E0372, // coherence not object safe - E0377, // the trait `CoerceUnsized` may only be implemented for a coercion - // between structures with the same definition -// E0558, // replaced with a generic attribute input check -// E0563, // cannot determine a type for this `impl Trait` removed in 6383de15 -// E0564, // only named lifetimes are allowed in `impl Trait`, - // but `{}` was found in the type `{}` -// E0611, // merged into E0616 -// E0612, // merged into E0609 -// E0613, // Removed (merged with E0609) - E0627, // yield statement outside of generator literal - E0632, // cannot provide explicit generic arguments when `impl Trait` is - // used in argument position - E0634, // type has conflicting packed representaton hints - E0640, // infer outlives requirements - E0641, // cannot cast to/from a pointer with an unknown kind -// E0645, // trait aliases not finished - E0719, // duplicate values for associated type binding - E0722, // Malformed `#[optimize]` attribute - E0724, // `#[ffi_returns_twice]` is only allowed in foreign functions -} diff --git a/src/librustc_typeck/impl_wf_check.rs b/src/librustc_typeck/impl_wf_check.rs index 2d188007712..28fc44dfad5 100644 --- a/src/librustc_typeck/impl_wf_check.rs +++ b/src/librustc_typeck/impl_wf_check.rs @@ -19,6 +19,8 @@ use std::collections::hash_map::Entry::{Occupied, Vacant}; use syntax_pos::Span; +use rustc_error_codes::*; + /// Checks that all the type/lifetime parameters on an impl also /// appear in the trait ref or self type (or are constrained by a /// where-clause). These rules are needed to ensure that, given a diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index a5a4cfa2bab..9289f3c7ef3 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -75,8 +75,6 @@ This API is completely unstable and subject to change. #[macro_use] extern crate rustc; -pub mod error_codes; - mod astconv; mod check; mod check_unused; @@ -106,6 +104,8 @@ use rustc::util; use syntax_pos::{DUMMY_SP, Span}; use util::common::time; +use rustc_error_codes::*; + use std::iter; use astconv::{AstConv, Bounds}; diff --git a/src/librustc_typeck/outlives/test.rs b/src/librustc_typeck/outlives/test.rs index 3ae646b3ac7..aa5272fd4e0 100644 --- a/src/librustc_typeck/outlives/test.rs +++ b/src/librustc_typeck/outlives/test.rs @@ -3,6 +3,8 @@ use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::ty::TyCtxt; use syntax::symbol::sym; +use rustc_error_codes::*; + pub fn test_inferred_outlives(tcx: TyCtxt<'_>) { tcx.hir() .krate() diff --git a/src/librustc_typeck/structured_errors.rs b/src/librustc_typeck/structured_errors.rs index 273a36edc56..cedd6e6fdb2 100644 --- a/src/librustc_typeck/structured_errors.rs +++ b/src/librustc_typeck/structured_errors.rs @@ -3,6 +3,8 @@ use syntax_pos::Span; use errors::{Applicability, DiagnosticId, DiagnosticBuilder}; use rustc::ty::{Ty, TypeFoldable}; +use rustc_error_codes::*; + pub trait StructuredDiagnostic<'tcx> { fn session(&self) -> &Session; diff --git a/src/librustc_typeck/variance/test.rs b/src/librustc_typeck/variance/test.rs index 9f6266b316f..a7fadb5459e 100644 --- a/src/librustc_typeck/variance/test.rs +++ b/src/librustc_typeck/variance/test.rs @@ -3,6 +3,8 @@ use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::ty::TyCtxt; use syntax::symbol::sym; +use rustc_error_codes::*; + pub fn test_variance(tcx: TyCtxt<'_>) { tcx.hir().krate().visit_all_item_likes(&mut VarianceTest { tcx }); } diff --git a/src/libsyntax/Cargo.toml b/src/libsyntax/Cargo.toml index 3e17e7949ea..d96b5b7a3dd 100644 --- a/src/libsyntax/Cargo.toml +++ b/src/libsyntax/Cargo.toml @@ -21,3 +21,4 @@ rustc_data_structures = { path = "../librustc_data_structures" } rustc_index = { path = "../librustc_index" } rustc_lexer = { path = "../librustc_lexer" } smallvec = { version = "1.0", features = ["union", "may_dangle"] } +rustc_error_codes = { path = "../librustc_error_codes" } diff --git a/src/libsyntax/attr/builtin.rs b/src/libsyntax/attr/builtin.rs index 2b759c205f5..acf0dd1cabb 100644 --- a/src/libsyntax/attr/builtin.rs +++ b/src/libsyntax/attr/builtin.rs @@ -12,6 +12,8 @@ use syntax_pos::{symbol::Symbol, symbol::sym, Span}; use super::{mark_used, MetaItemKind}; +use rustc_error_codes::*; + enum AttrError { MultipleItem(String), UnknownMetaItem(String, &'static [&'static str]), diff --git a/src/libsyntax/diagnostics/macros.rs b/src/libsyntax/diagnostics/macros.rs index c95c5bd5d02..6679b4459a0 100644 --- a/src/libsyntax/diagnostics/macros.rs +++ b/src/libsyntax/diagnostics/macros.rs @@ -1,7 +1,7 @@ #[macro_export] macro_rules! diagnostic_used { ($code:ident) => ( - let _ = crate::error_codes::$code; + let _ = $code; ) } @@ -167,25 +167,3 @@ macro_rules! help { ($err).help(&format!($($message)*)); }) } - -#[macro_export] -macro_rules! register_diagnostics { - ($($ecode:ident: $message:expr,)*) => ( - $crate::register_diagnostics!{$($ecode:$message,)* ;} - ); - - ($($ecode:ident: $message:expr,)* ; $($code:ident,)*) => ( - pub static DIAGNOSTICS: &[(&str, &str)] = &[ - $( (stringify!($ecode), $message), )* - ]; - - $( - #[deny(unused)] - pub(crate) const $ecode: &str = $message; - )* - $( - #[deny(unused)] - pub(crate) const $code: () = (); - )* - ) -} diff --git a/src/libsyntax/error_codes.rs b/src/libsyntax/error_codes.rs deleted file mode 100644 index 0e81de7d4a7..00000000000 --- a/src/libsyntax/error_codes.rs +++ /dev/null @@ -1,379 +0,0 @@ -// Error messages for EXXXX errors. -// Each message should start and end with a new line, and be wrapped to 80 -// characters. In vim you can `:set tw=80` and use `gq` to wrap paragraphs. Use -// `:set tw=0` to disable. -register_diagnostics! { - -E0536: r##" -The `not` cfg-predicate was malformed. - -Erroneous code example: - -```compile_fail,E0536 -#[cfg(not())] // error: expected 1 cfg-pattern -pub fn something() {} - -pub fn main() {} -``` - -The `not` predicate expects one cfg-pattern. Example: - -``` -#[cfg(not(target_os = "linux"))] // ok! -pub fn something() {} - -pub fn main() {} -``` - -For more information about the cfg attribute, read: -https://doc.rust-lang.org/reference.html#conditional-compilation -"##, - -E0537: r##" -An unknown predicate was used inside the `cfg` attribute. - -Erroneous code example: - -```compile_fail,E0537 -#[cfg(unknown())] // error: invalid predicate `unknown` -pub fn something() {} - -pub fn main() {} -``` - -The `cfg` attribute supports only three kinds of predicates: - - * any - * all - * not - -Example: - -``` -#[cfg(not(target_os = "linux"))] // ok! -pub fn something() {} - -pub fn main() {} -``` - -For more information about the cfg attribute, read: -https://doc.rust-lang.org/reference.html#conditional-compilation -"##, - -E0538: r##" -Attribute contains same meta item more than once. - -Erroneous code example: - -```compile_fail,E0538 -#[deprecated( - since="1.0.0", - note="First deprecation note.", - note="Second deprecation note." // error: multiple same meta item -)] -fn deprecated_function() {} -``` - -Meta items are the key-value pairs inside of an attribute. Each key may only be -used once in each attribute. - -To fix the problem, remove all but one of the meta items with the same key. - -Example: - -``` -#[deprecated( - since="1.0.0", - note="First deprecation note." -)] -fn deprecated_function() {} -``` -"##, - -E0541: r##" -An unknown meta item was used. - -Erroneous code example: - -```compile_fail,E0541 -#[deprecated( - since="1.0.0", - // error: unknown meta item - reason="Example invalid meta item. Should be 'note'") -] -fn deprecated_function() {} -``` - -Meta items are the key-value pairs inside of an attribute. The keys provided -must be one of the valid keys for the specified attribute. - -To fix the problem, either remove the unknown meta item, or rename it if you -provided the wrong name. - -In the erroneous code example above, the wrong name was provided, so changing -to a correct one it will fix the error. Example: - -``` -#[deprecated( - since="1.0.0", - note="This is a valid meta item for the deprecated attribute." -)] -fn deprecated_function() {} -``` -"##, - -E0550: r##" -More than one `deprecated` attribute has been put on an item. - -Erroneous code example: - -```compile_fail,E0550 -#[deprecated(note = "because why not?")] -#[deprecated(note = "right?")] // error! -fn the_banished() {} -``` - -The `deprecated` attribute can only be present **once** on an item. - -``` -#[deprecated(note = "because why not, right?")] -fn the_banished() {} // ok! -``` -"##, - -E0551: r##" -An invalid meta-item was used inside an attribute. - -Erroneous code example: - -```compile_fail,E0551 -#[deprecated(note)] // error! -fn i_am_deprecated() {} -``` - -Meta items are the key-value pairs inside of an attribute. To fix this issue, -you need to give a value to the `note` key. Example: - -``` -#[deprecated(note = "because")] // ok! -fn i_am_deprecated() {} -``` -"##, - -E0552: r##" -A unrecognized representation attribute was used. - -Erroneous code example: - -```compile_fail,E0552 -#[repr(D)] // error: unrecognized representation hint -struct MyStruct { - my_field: usize -} -``` - -You can use a `repr` attribute to tell the compiler how you want a struct or -enum to be laid out in memory. - -Make sure you're using one of the supported options: - -``` -#[repr(C)] // ok! -struct MyStruct { - my_field: usize -} -``` - -For more information about specifying representations, see the ["Alternative -Representations" section] of the Rustonomicon. - -["Alternative Representations" section]: https://doc.rust-lang.org/nomicon/other-reprs.html -"##, - -E0554: r##" -Feature attributes are only allowed on the nightly release channel. Stable or -beta compilers will not comply. - -Example of erroneous code (on a stable compiler): - -```ignore (depends on release channel) -#![feature(non_ascii_idents)] // error: `#![feature]` may not be used on the - // stable release channel -``` - -If you need the feature, make sure to use a nightly release of the compiler -(but be warned that the feature may be removed or altered in the future). -"##, - -E0556: r##" -The `feature` attribute was badly formed. - -Erroneous code example: - -```compile_fail,E0556 -#![feature(foo_bar_baz, foo(bar), foo = "baz", foo)] // error! -#![feature] // error! -#![feature = "foo"] // error! -``` - -The `feature` attribute only accept a "feature flag" and can only be used on -nightly. Example: - -```ignore (only works in nightly) -#![feature(flag)] -``` -"##, - -E0557: r##" -A feature attribute named a feature that has been removed. - -Erroneous code example: - -```compile_fail,E0557 -#![feature(managed_boxes)] // error: feature has been removed -``` - -Delete the offending feature attribute. -"##, - -E0565: r##" -A literal was used in a built-in attribute that doesn't support literals. - -Erroneous code example: - -```ignore (compile_fail not working here; see Issue #43707) -#[inline("always")] // error: unsupported literal -pub fn something() {} -``` - -Literals in attributes are new and largely unsupported in built-in attributes. -Work to support literals where appropriate is ongoing. Try using an unquoted -name instead: - -``` -#[inline(always)] -pub fn something() {} -``` -"##, - -E0589: r##" -The value of `N` that was specified for `repr(align(N))` was not a power -of two, or was greater than 2^29. - -```compile_fail,E0589 -#[repr(align(15))] // error: invalid `repr(align)` attribute: not a power of two -enum Foo { - Bar(u64), -} -``` -"##, - -E0658: r##" -An unstable feature was used. - -Erroneous code example: - -```compile_fail,E658 -#[repr(u128)] // error: use of unstable library feature 'repr128' -enum Foo { - Bar(u64), -} -``` - -If you're using a stable or a beta version of rustc, you won't be able to use -any unstable features. In order to do so, please switch to a nightly version of -rustc (by using rustup). - -If you're using a nightly version of rustc, just add the corresponding feature -to be able to use it: - -``` -#![feature(repr128)] - -#[repr(u128)] // ok! -enum Foo { - Bar(u64), -} -``` -"##, - -E0633: r##" -The `unwind` attribute was malformed. - -Erroneous code example: - -```ignore (compile_fail not working here; see Issue #43707) -#[unwind()] // error: expected one argument -pub extern fn something() {} - -fn main() {} -``` - -The `#[unwind]` attribute should be used as follows: - -- `#[unwind(aborts)]` -- specifies that if a non-Rust ABI function - should abort the process if it attempts to unwind. This is the safer - and preferred option. - -- `#[unwind(allowed)]` -- specifies that a non-Rust ABI function - should be allowed to unwind. This can easily result in Undefined - Behavior (UB), so be careful. - -NB. The default behavior here is "allowed", but this is unspecified -and likely to change in the future. - -"##, - -E0705: r##" -A `#![feature]` attribute was declared for a feature that is stable in -the current edition, but not in all editions. - -Erroneous code example: - -```ignore (limited to a warning during 2018 edition development) -#![feature(rust_2018_preview)] -#![feature(test_2018_feature)] // error: the feature - // `test_2018_feature` is - // included in the Rust 2018 edition -``` -"##, - -E0725: r##" -A feature attribute named a feature that was disallowed in the compiler -command line flags. - -Erroneous code example: - -```ignore (can't specify compiler flags from doctests) -#![feature(never_type)] // error: the feature `never_type` is not in - // the list of allowed features -``` - -Delete the offending feature attribute, or add it to the list of allowed -features in the `-Z allow_features` flag. -"##, - -; - - E0539, // incorrect meta item - E0540, // multiple rustc_deprecated attributes - E0542, // missing 'since' - E0543, // missing 'reason' - E0544, // multiple stability levels - E0545, // incorrect 'issue' - E0546, // missing 'feature' - E0547, // missing 'issue' -// E0548, // replaced with a generic attribute input check - // rustc_deprecated attribute must be paired with either stable or unstable - // attribute - E0549, - E0553, // multiple rustc_const_unstable attributes -// E0555, // replaced with a generic attribute input check - E0629, // missing 'feature' (rustc_const_unstable) - // rustc_const_unstable attribute must be paired with stable/unstable - // attribute - E0630, - E0693, // incorrect `repr(align)` attribute format -// E0694, // an unknown tool name found in scoped attributes - E0717, // rustc_promotable without stability attribute -} diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs index 3bf1e24bf12..d95dac9bf52 100644 --- a/src/libsyntax/feature_gate/check.rs +++ b/src/libsyntax/feature_gate/check.rs @@ -17,6 +17,9 @@ use rustc_data_structures::fx::FxHashMap; use syntax_pos::{Span, DUMMY_SP, MultiSpan}; use log::debug; +use rustc_error_codes::*; + + use std::env; use std::num::NonZeroU32; diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index 317fcf29389..6290b2137ea 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -77,8 +77,6 @@ pub mod diagnostics { pub mod macros; } -pub mod error_codes; - pub mod util { pub mod classify; pub mod comments; diff --git a/src/libsyntax_ext/Cargo.toml b/src/libsyntax_ext/Cargo.toml index 5ae8b3a3e0c..2ebdac8ef7c 100644 --- a/src/libsyntax_ext/Cargo.toml +++ b/src/libsyntax_ext/Cargo.toml @@ -20,3 +20,4 @@ smallvec = { version = "1.0", features = ["union", "may_dangle"] } syntax = { path = "../libsyntax" } syntax_expand = { path = "../libsyntax_expand" } syntax_pos = { path = "../libsyntax_pos" } +rustc_error_codes = { path = "../librustc_error_codes" } diff --git a/src/libsyntax_ext/asm.rs b/src/libsyntax_ext/asm.rs index 539d777105d..5fab101957a 100644 --- a/src/libsyntax_ext/asm.rs +++ b/src/libsyntax_ext/asm.rs @@ -16,6 +16,8 @@ use syntax_pos::Span; use syntax::tokenstream::{self, TokenStream}; use syntax::{span_err, struct_span_err}; +use rustc_error_codes::*; + enum State { Asm, Outputs, diff --git a/src/libsyntax_ext/deriving/default.rs b/src/libsyntax_ext/deriving/default.rs index cfc0f3cd6cb..ab57f395f6a 100644 --- a/src/libsyntax_ext/deriving/default.rs +++ b/src/libsyntax_ext/deriving/default.rs @@ -9,6 +9,8 @@ use syntax::symbol::{kw, sym}; use syntax::span_err; use syntax_pos::Span; +use rustc_error_codes::*; + pub fn expand_deriving_default(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, diff --git a/src/libsyntax_ext/error_codes.rs b/src/libsyntax_ext/error_codes.rs deleted file mode 100644 index 2bc990574f7..00000000000 --- a/src/libsyntax_ext/error_codes.rs +++ /dev/null @@ -1,120 +0,0 @@ -// Error messages for EXXXX errors. -// Each message should start and end with a new line, and be wrapped to 80 -// characters. In vim you can `:set tw=80` and use `gq` to wrap paragraphs. Use -// `:set tw=0` to disable. -syntax::register_diagnostics! { -E0660: r##" -The argument to the `asm` macro is not well-formed. - -Erroneous code example: - -```compile_fail,E0660 -asm!("nop" "nop"); -``` - -Considering that this would be a long explanation, we instead recommend you to -take a look at the unstable book: -https://doc.rust-lang.org/unstable-book/language-features/asm.html -"##, - -E0661: r##" -An invalid syntax was passed to the second argument of an `asm` macro line. - -Erroneous code example: - -```compile_fail,E0661 -let a; -asm!("nop" : "r"(a)); -``` - -Considering that this would be a long explanation, we instead recommend you to -take a look at the unstable book: -https://doc.rust-lang.org/unstable-book/language-features/asm.html -"##, - -E0662: r##" -An invalid input operand constraint was passed to the `asm` macro (third line). - -Erroneous code example: - -```compile_fail,E0662 -asm!("xor %eax, %eax" - : - : "=test"("a") - ); -``` - -Considering that this would be a long explanation, we instead recommend you to -take a look at the unstable book: -https://doc.rust-lang.org/unstable-book/language-features/asm.html -"##, - -E0663: r##" -An invalid input operand constraint was passed to the `asm` macro (third line). - -Erroneous code example: - -```compile_fail,E0663 -asm!("xor %eax, %eax" - : - : "+test"("a") - ); -``` - -Considering that this would be a long explanation, we instead recommend you to -take a look at the unstable book: -https://doc.rust-lang.org/unstable-book/language-features/asm.html -"##, - -E0664: r##" -A clobber was surrounded by braces in the `asm` macro. - -Erroneous code example: - -```compile_fail,E0664 -asm!("mov $$0x200, %eax" - : - : - : "{eax}" - ); -``` - -Considering that this would be a long explanation, we instead recommend you to -take a look at the unstable book: -https://doc.rust-lang.org/unstable-book/language-features/asm.html -"##, - -E0665: r##" -The `Default` trait was derived on an enum. - -Erroneous code example: - -```compile_fail,E0665 -#[derive(Default)] -enum Food { - Sweet, - Salty, -} -``` - -The `Default` cannot be derived on an enum for the simple reason that the -compiler doesn't know which value to pick by default whereas it can for a -struct as long as all its fields implement the `Default` trait as well. - -If you still want to implement `Default` on your enum, you'll have to do it "by -hand": - -``` -enum Food { - Sweet, - Salty, -} - -impl Default for Food { - fn default() -> Food { - Food::Sweet - } -} -``` -"##, -} diff --git a/src/libsyntax_ext/lib.rs b/src/libsyntax_ext/lib.rs index 5516f276422..07fdec05046 100644 --- a/src/libsyntax_ext/lib.rs +++ b/src/libsyntax_ext/lib.rs @@ -19,8 +19,6 @@ use syntax::symbol::sym; use syntax_expand::base::{Resolver, SyntaxExtension, SyntaxExtensionKind, MacroExpanderFn}; use syntax_expand::proc_macro::BangProcMacro; -mod error_codes; - mod asm; mod assert; mod cfg; diff --git a/src/test/ui/asm/asm-bad-clobber.stderr b/src/test/ui/asm/asm-bad-clobber.stderr index 15a14e776ba..a279421241f 100644 --- a/src/test/ui/asm/asm-bad-clobber.stderr +++ b/src/test/ui/asm/asm-bad-clobber.stderr @@ -6,3 +6,4 @@ LL | asm!("xor %eax, %eax" : : : "{eax}"); error: aborting due to previous error +For more information about this error, try `rustc --explain E0664`. diff --git a/src/test/ui/asm/asm-in-bad-modifier.stderr b/src/test/ui/asm/asm-in-bad-modifier.stderr index b71eb8649ba..d45b3e57038 100644 --- a/src/test/ui/asm/asm-in-bad-modifier.stderr +++ b/src/test/ui/asm/asm-in-bad-modifier.stderr @@ -12,3 +12,5 @@ LL | asm!("mov $1, $0" : "=r"(y) : "+r"(5)); error: aborting due to 2 previous errors +Some errors have detailed explanations: E0662, E0663. +For more information about an error, try `rustc --explain E0662`. diff --git a/src/test/ui/asm/asm-out-no-modifier.stderr b/src/test/ui/asm/asm-out-no-modifier.stderr index 387a603f90e..99134ceba33 100644 --- a/src/test/ui/asm/asm-out-no-modifier.stderr +++ b/src/test/ui/asm/asm-out-no-modifier.stderr @@ -6,3 +6,4 @@ LL | asm!("mov $1, $0" : "r"(x) : "r"(5)); error: aborting due to previous error +For more information about this error, try `rustc --explain E0661`. diff --git a/src/test/ui/asm/issue-51431.stderr b/src/test/ui/asm/issue-51431.stderr index 132eea126d6..f78d1831973 100644 --- a/src/test/ui/asm/issue-51431.stderr +++ b/src/test/ui/asm/issue-51431.stderr @@ -6,3 +6,4 @@ LL | asm! {"mov $0,$1"::"0"("bx"),"1"(0x00)} error: aborting due to previous error +For more information about this error, try `rustc --explain E0669`. diff --git a/src/test/ui/bad/bad-intrinsic-monomorphization.stderr b/src/test/ui/bad/bad-intrinsic-monomorphization.stderr index 34fdba11367..dee33f574d8 100644 --- a/src/test/ui/bad/bad-intrinsic-monomorphization.stderr +++ b/src/test/ui/bad/bad-intrinsic-monomorphization.stderr @@ -18,3 +18,4 @@ LL | simd_add(a, b) error: aborting due to 3 previous errors +For more information about this error, try `rustc --explain E0511`. diff --git a/src/test/ui/error-codes/E0511.stderr b/src/test/ui/error-codes/E0511.stderr index 5f8be0c61d3..1362a3d1f25 100644 --- a/src/test/ui/error-codes/E0511.stderr +++ b/src/test/ui/error-codes/E0511.stderr @@ -6,3 +6,4 @@ LL | unsafe { simd_add(0, 1); } error: aborting due to previous error +For more information about this error, try `rustc --explain E0511`. diff --git a/src/test/ui/error-codes/E0660.stderr b/src/test/ui/error-codes/E0660.stderr index ce34a9b01d7..d355531ef5d 100644 --- a/src/test/ui/error-codes/E0660.stderr +++ b/src/test/ui/error-codes/E0660.stderr @@ -12,3 +12,4 @@ LL | asm!("nop" "nop" : "=r"(a)); error: aborting due to 2 previous errors +For more information about this error, try `rustc --explain E0660`. diff --git a/src/test/ui/error-codes/E0661.stderr b/src/test/ui/error-codes/E0661.stderr index 3537e0bc3a4..6e849649aca 100644 --- a/src/test/ui/error-codes/E0661.stderr +++ b/src/test/ui/error-codes/E0661.stderr @@ -12,4 +12,5 @@ LL | let a; error: aborting due to 2 previous errors -For more information about this error, try `rustc --explain E0282`. +Some errors have detailed explanations: E0282, E0661. +For more information about an error, try `rustc --explain E0282`. diff --git a/src/test/ui/error-codes/E0662.stderr b/src/test/ui/error-codes/E0662.stderr index 3b2f7632f39..7480f03c3d4 100644 --- a/src/test/ui/error-codes/E0662.stderr +++ b/src/test/ui/error-codes/E0662.stderr @@ -6,3 +6,4 @@ LL | : "=test"("a") error: aborting due to previous error +For more information about this error, try `rustc --explain E0662`. diff --git a/src/test/ui/error-codes/E0663.stderr b/src/test/ui/error-codes/E0663.stderr index 4ac0a85f26d..2b7598d1577 100644 --- a/src/test/ui/error-codes/E0663.stderr +++ b/src/test/ui/error-codes/E0663.stderr @@ -6,3 +6,4 @@ LL | : "+test"("a") error: aborting due to previous error +For more information about this error, try `rustc --explain E0663`. diff --git a/src/test/ui/error-codes/E0664.stderr b/src/test/ui/error-codes/E0664.stderr index 435e465920b..224fc63696a 100644 --- a/src/test/ui/error-codes/E0664.stderr +++ b/src/test/ui/error-codes/E0664.stderr @@ -6,3 +6,4 @@ LL | : "{eax}" error: aborting due to previous error +For more information about this error, try `rustc --explain E0664`. diff --git a/src/test/ui/error-codes/E0665.stderr b/src/test/ui/error-codes/E0665.stderr index 84fe3c01394..2c2b498e39a 100644 --- a/src/test/ui/error-codes/E0665.stderr +++ b/src/test/ui/error-codes/E0665.stderr @@ -6,3 +6,4 @@ LL | #[derive(Default)] error: aborting due to previous error +For more information about this error, try `rustc --explain E0665`. diff --git a/src/test/ui/inline-asm-bad-constraint.stderr b/src/test/ui/inline-asm-bad-constraint.stderr index 37e71a94c16..59066e5e7fc 100644 --- a/src/test/ui/inline-asm-bad-constraint.stderr +++ b/src/test/ui/inline-asm-bad-constraint.stderr @@ -18,3 +18,4 @@ LL | asm!("addb $1, $0" : "={rax}"((0i32, rax))); error: aborting due to 3 previous errors +For more information about this error, try `rustc --explain E0668`. diff --git a/src/test/ui/inline-asm-bad-operand.stderr b/src/test/ui/inline-asm-bad-operand.stderr index 55523bad6c5..b8e7e9acfec 100644 --- a/src/test/ui/inline-asm-bad-operand.stderr +++ b/src/test/ui/inline-asm-bad-operand.stderr @@ -42,3 +42,4 @@ LL | ... "r"("hello e0669")); error: aborting due to 7 previous errors +For more information about this error, try `rustc --explain E0669`. diff --git a/src/test/ui/issues/issue-37433.stderr b/src/test/ui/issues/issue-37433.stderr index eec04469025..956694fc2cd 100644 --- a/src/test/ui/issues/issue-37433.stderr +++ b/src/test/ui/issues/issue-37433.stderr @@ -6,3 +6,4 @@ LL | asm!("" :: "r"("")); error: aborting due to previous error +For more information about this error, try `rustc --explain E0669`. diff --git a/src/test/ui/issues/issue-53787-inline-assembler-macro.stderr b/src/test/ui/issues/issue-53787-inline-assembler-macro.stderr index 6a4416d78f3..f96bcaa492c 100644 --- a/src/test/ui/issues/issue-53787-inline-assembler-macro.stderr +++ b/src/test/ui/issues/issue-53787-inline-assembler-macro.stderr @@ -6,3 +6,4 @@ LL | fake_jump!("FirstFunc"); error: aborting due to previous error +For more information about this error, try `rustc --explain E0669`. diff --git a/src/test/ui/json-bom-plus-crlf-multifile.stderr b/src/test/ui/json-bom-plus-crlf-multifile.stderr index 8472f161089..39f6b69bbec 100644 --- a/src/test/ui/json-bom-plus-crlf-multifile.stderr +++ b/src/test/ui/json-bom-plus-crlf-multifile.stderr @@ -1,5 +1,4 @@ -{"message":"mismatched types","code":{"code":"E0308","explanation":" -This error occurs when the compiler was unable to infer the concrete type of a +{"message":"mismatched types","code":{"code":"E0308","explanation":"This error occurs when the compiler was unable to infer the concrete type of a variable. It can occur for several cases, the most common of which is a mismatch in the expected type that the compiler inferred for a variable's initializing expression, and the actual type explicitly assigned to the @@ -19,8 +18,7 @@ let x: i32 = \"I am not a number!\"; "},"level":"error","spans":[{"file_name":"$DIR/json-bom-plus-crlf-multifile-aux.rs","byte_start":621,"byte_end":622,"line_start":17,"line_end":17,"column_start":22,"column_end":23,"is_primary":true,"text":[{"text":" let s : String = 1; // Error in the middle of line.","highlight_start":22,"highlight_end":23}],"label":"expected struct `std::string::String`, found integer","suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"expected type `std::string::String` found type `{integer}`","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"try using a conversion method","code":null,"level":"help","spans":[{"file_name":"$DIR/json-bom-plus-crlf-multifile-aux.rs","byte_start":621,"byte_end":622,"line_start":17,"line_end":17,"column_start":22,"column_end":23,"is_primary":true,"text":[{"text":" let s : String = 1; // Error in the middle of line.","highlight_start":22,"highlight_end":23}],"label":null,"suggested_replacement":"1.to_string()","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"$DIR/json-bom-plus-crlf-multifile-aux.rs:17:22: error[E0308]: mismatched types "} -{"message":"mismatched types","code":{"code":"E0308","explanation":" -This error occurs when the compiler was unable to infer the concrete type of a +{"message":"mismatched types","code":{"code":"E0308","explanation":"This error occurs when the compiler was unable to infer the concrete type of a variable. It can occur for several cases, the most common of which is a mismatch in the expected type that the compiler inferred for a variable's initializing expression, and the actual type explicitly assigned to the @@ -40,8 +38,7 @@ let x: i32 = \"I am not a number!\"; "},"level":"error","spans":[{"file_name":"$DIR/json-bom-plus-crlf-multifile-aux.rs","byte_start":681,"byte_end":682,"line_start":19,"line_end":19,"column_start":22,"column_end":23,"is_primary":true,"text":[{"text":" let s : String = 1","highlight_start":22,"highlight_end":23}],"label":"expected struct `std::string::String`, found integer","suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"expected type `std::string::String` found type `{integer}`","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"try using a conversion method","code":null,"level":"help","spans":[{"file_name":"$DIR/json-bom-plus-crlf-multifile-aux.rs","byte_start":681,"byte_end":682,"line_start":19,"line_end":19,"column_start":22,"column_end":23,"is_primary":true,"text":[{"text":" let s : String = 1","highlight_start":22,"highlight_end":23}],"label":null,"suggested_replacement":"1.to_string()","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"$DIR/json-bom-plus-crlf-multifile-aux.rs:19:22: error[E0308]: mismatched types "} -{"message":"mismatched types","code":{"code":"E0308","explanation":" -This error occurs when the compiler was unable to infer the concrete type of a +{"message":"mismatched types","code":{"code":"E0308","explanation":"This error occurs when the compiler was unable to infer the concrete type of a variable. It can occur for several cases, the most common of which is a mismatch in the expected type that the compiler inferred for a variable's initializing expression, and the actual type explicitly assigned to the @@ -61,8 +58,7 @@ let x: i32 = \"I am not a number!\"; "},"level":"error","spans":[{"file_name":"$DIR/json-bom-plus-crlf-multifile-aux.rs","byte_start":745,"byte_end":746,"line_start":23,"line_end":23,"column_start":1,"column_end":2,"is_primary":true,"text":[{"text":"1; // Error after the newline.","highlight_start":1,"highlight_end":2}],"label":"expected struct `std::string::String`, found integer","suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"expected type `std::string::String` found type `{integer}`","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"try using a conversion method","code":null,"level":"help","spans":[{"file_name":"$DIR/json-bom-plus-crlf-multifile-aux.rs","byte_start":745,"byte_end":746,"line_start":23,"line_end":23,"column_start":1,"column_end":2,"is_primary":true,"text":[{"text":"1; // Error after the newline.","highlight_start":1,"highlight_end":2}],"label":null,"suggested_replacement":"1.to_string()","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"$DIR/json-bom-plus-crlf-multifile-aux.rs:23:1: error[E0308]: mismatched types "} -{"message":"mismatched types","code":{"code":"E0308","explanation":" -This error occurs when the compiler was unable to infer the concrete type of a +{"message":"mismatched types","code":{"code":"E0308","explanation":"This error occurs when the compiler was unable to infer the concrete type of a variable. It can occur for several cases, the most common of which is a mismatch in the expected type that the compiler inferred for a variable's initializing expression, and the actual type explicitly assigned to the diff --git a/src/test/ui/json-bom-plus-crlf.stderr b/src/test/ui/json-bom-plus-crlf.stderr index 17775f59fd1..d62140e4de7 100644 --- a/src/test/ui/json-bom-plus-crlf.stderr +++ b/src/test/ui/json-bom-plus-crlf.stderr @@ -1,5 +1,4 @@ -{"message":"mismatched types","code":{"code":"E0308","explanation":" -This error occurs when the compiler was unable to infer the concrete type of a +{"message":"mismatched types","code":{"code":"E0308","explanation":"This error occurs when the compiler was unable to infer the concrete type of a variable. It can occur for several cases, the most common of which is a mismatch in the expected type that the compiler inferred for a variable's initializing expression, and the actual type explicitly assigned to the @@ -19,8 +18,7 @@ let x: i32 = \"I am not a number!\"; "},"level":"error","spans":[{"file_name":"$DIR/json-bom-plus-crlf.rs","byte_start":621,"byte_end":622,"line_start":17,"line_end":17,"column_start":22,"column_end":23,"is_primary":true,"text":[{"text":" let s : String = 1; // Error in the middle of line.","highlight_start":22,"highlight_end":23}],"label":"expected struct `std::string::String`, found integer","suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"expected type `std::string::String` found type `{integer}`","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"try using a conversion method","code":null,"level":"help","spans":[{"file_name":"$DIR/json-bom-plus-crlf.rs","byte_start":621,"byte_end":622,"line_start":17,"line_end":17,"column_start":22,"column_end":23,"is_primary":true,"text":[{"text":" let s : String = 1; // Error in the middle of line.","highlight_start":22,"highlight_end":23}],"label":null,"suggested_replacement":"1.to_string()","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"$DIR/json-bom-plus-crlf.rs:17:22: error[E0308]: mismatched types "} -{"message":"mismatched types","code":{"code":"E0308","explanation":" -This error occurs when the compiler was unable to infer the concrete type of a +{"message":"mismatched types","code":{"code":"E0308","explanation":"This error occurs when the compiler was unable to infer the concrete type of a variable. It can occur for several cases, the most common of which is a mismatch in the expected type that the compiler inferred for a variable's initializing expression, and the actual type explicitly assigned to the @@ -40,8 +38,7 @@ let x: i32 = \"I am not a number!\"; "},"level":"error","spans":[{"file_name":"$DIR/json-bom-plus-crlf.rs","byte_start":681,"byte_end":682,"line_start":19,"line_end":19,"column_start":22,"column_end":23,"is_primary":true,"text":[{"text":" let s : String = 1","highlight_start":22,"highlight_end":23}],"label":"expected struct `std::string::String`, found integer","suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"expected type `std::string::String` found type `{integer}`","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"try using a conversion method","code":null,"level":"help","spans":[{"file_name":"$DIR/json-bom-plus-crlf.rs","byte_start":681,"byte_end":682,"line_start":19,"line_end":19,"column_start":22,"column_end":23,"is_primary":true,"text":[{"text":" let s : String = 1","highlight_start":22,"highlight_end":23}],"label":null,"suggested_replacement":"1.to_string()","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"$DIR/json-bom-plus-crlf.rs:19:22: error[E0308]: mismatched types "} -{"message":"mismatched types","code":{"code":"E0308","explanation":" -This error occurs when the compiler was unable to infer the concrete type of a +{"message":"mismatched types","code":{"code":"E0308","explanation":"This error occurs when the compiler was unable to infer the concrete type of a variable. It can occur for several cases, the most common of which is a mismatch in the expected type that the compiler inferred for a variable's initializing expression, and the actual type explicitly assigned to the @@ -61,8 +58,7 @@ let x: i32 = \"I am not a number!\"; "},"level":"error","spans":[{"file_name":"$DIR/json-bom-plus-crlf.rs","byte_start":745,"byte_end":746,"line_start":23,"line_end":23,"column_start":1,"column_end":2,"is_primary":true,"text":[{"text":"1; // Error after the newline.","highlight_start":1,"highlight_end":2}],"label":"expected struct `std::string::String`, found integer","suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"expected type `std::string::String` found type `{integer}`","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"try using a conversion method","code":null,"level":"help","spans":[{"file_name":"$DIR/json-bom-plus-crlf.rs","byte_start":745,"byte_end":746,"line_start":23,"line_end":23,"column_start":1,"column_end":2,"is_primary":true,"text":[{"text":"1; // Error after the newline.","highlight_start":1,"highlight_end":2}],"label":null,"suggested_replacement":"1.to_string()","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"$DIR/json-bom-plus-crlf.rs:23:1: error[E0308]: mismatched types "} -{"message":"mismatched types","code":{"code":"E0308","explanation":" -This error occurs when the compiler was unable to infer the concrete type of a +{"message":"mismatched types","code":{"code":"E0308","explanation":"This error occurs when the compiler was unable to infer the concrete type of a variable. It can occur for several cases, the most common of which is a mismatch in the expected type that the compiler inferred for a variable's initializing expression, and the actual type explicitly assigned to the diff --git a/src/test/ui/json-short.stderr b/src/test/ui/json-short.stderr index d9f68023ce7..83fc83778a8 100644 --- a/src/test/ui/json-short.stderr +++ b/src/test/ui/json-short.stderr @@ -1,5 +1,4 @@ -{"message":"`main` function not found in crate `json_short`","code":{"code":"E0601","explanation":" -No `main` function was found in a binary crate. To fix this error, add a +{"message":"`main` function not found in crate `json_short`","code":{"code":"E0601","explanation":"No `main` function was found in a binary crate. To fix this error, add a `main` function. For example: ``` diff --git a/src/test/ui/lint/use_suggestion_json.stderr b/src/test/ui/lint/use_suggestion_json.stderr index 3e77d193fa4..0dc0d247af5 100644 --- a/src/test/ui/lint/use_suggestion_json.stderr +++ b/src/test/ui/lint/use_suggestion_json.stderr @@ -2,8 +2,7 @@ "message": "cannot find type `Iter` in this scope", "code": { "code": "E0412", - "explanation": " -The type name used is not in scope. + "explanation": "The type name used is not in scope. Erroneous code examples: diff --git a/src/test/ui/macros/macros-nonfatal-errors.stderr b/src/test/ui/macros/macros-nonfatal-errors.stderr index b2fdbb736c8..d29e6b4d46f 100644 --- a/src/test/ui/macros/macros-nonfatal-errors.stderr +++ b/src/test/ui/macros/macros-nonfatal-errors.stderr @@ -89,3 +89,4 @@ LL | trace_macros!(invalid); error: aborting due to 14 previous errors +For more information about this error, try `rustc --explain E0665`. diff --git a/src/test/ui/non-integer-atomic.stderr b/src/test/ui/non-integer-atomic.stderr index b3cf788d834..2a06b617aec 100644 --- a/src/test/ui/non-integer-atomic.stderr +++ b/src/test/ui/non-integer-atomic.stderr @@ -96,3 +96,4 @@ LL | intrinsics::atomic_cxchg(p, v, v); error: aborting due to 16 previous errors +For more information about this error, try `rustc --explain E0511`. diff --git a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.stderr b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.stderr index e10ac2e1192..0e88540bcc8 100644 --- a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.stderr +++ b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.stderr @@ -12,3 +12,4 @@ LL | simd_saturating_sub(z, z); error: aborting due to 2 previous errors +For more information about this error, try `rustc --explain E0511`. diff --git a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-arithmetic.stderr b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-arithmetic.stderr index 014db52504f..27493950af0 100644 --- a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-arithmetic.stderr +++ b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-arithmetic.stderr @@ -84,3 +84,4 @@ LL | simd_xor(z, z); error: aborting due to 14 previous errors +For more information about this error, try `rustc --explain E0511`. diff --git a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-bitmask.stderr b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-bitmask.stderr index f9135d1cbfe..d016838d098 100644 --- a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-bitmask.stderr +++ b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-bitmask.stderr @@ -30,3 +30,4 @@ LL | let _: u128 = simd_bitmask(m64); error: aborting due to 5 previous errors +For more information about this error, try `rustc --explain E0511`. diff --git a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-cast.stderr b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-cast.stderr index 333f92a40a8..6e33e3b30f5 100644 --- a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-cast.stderr +++ b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-cast.stderr @@ -24,3 +24,4 @@ LL | simd_cast::<_, i32x8>(x); error: aborting due to 4 previous errors +For more information about this error, try `rustc --explain E0511`. diff --git a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-comparison.stderr b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-comparison.stderr index cea319f1bc8..d8da2e5ee57 100644 --- a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-comparison.stderr +++ b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-comparison.stderr @@ -108,3 +108,4 @@ LL | simd_ge::<_, i16x8>(x, x); error: aborting due to 18 previous errors +For more information about this error, try `rustc --explain E0511`. diff --git a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-elements.stderr b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-elements.stderr index 3a84567b53a..2f8ffb6035e 100644 --- a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-elements.stderr +++ b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-elements.stderr @@ -90,3 +90,4 @@ LL | simd_shuffle8::<_, i32x2>(x, x, [0; 8]); error: aborting due to 15 previous errors +For more information about this error, try `rustc --explain E0511`. diff --git a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-reduction.stderr b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-reduction.stderr index 3863eeac3f3..5f2a67dc14e 100644 --- a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-reduction.stderr +++ b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-reduction.stderr @@ -60,3 +60,4 @@ LL | let _: bool = simd_reduce_any(z); error: aborting due to 10 previous errors +For more information about this error, try `rustc --explain E0511`. diff --git a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-select.stderr b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-select.stderr index e03e396fdf4..a46352c7308 100644 --- a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-select.stderr +++ b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-select.stderr @@ -48,3 +48,4 @@ LL | simd_select_bitmask("x", x, x); error: aborting due to 8 previous errors +For more information about this error, try `rustc --explain E0511`. diff --git a/src/tools/error_index_generator/build.rs b/src/tools/error_index_generator/build.rs index c59533da1dc..b04aff4939b 100644 --- a/src/tools/error_index_generator/build.rs +++ b/src/tools/error_index_generator/build.rs @@ -8,19 +8,26 @@ fn main() { // directory. let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap()); let dest = out_dir.join("error_codes.rs"); - let mut idx = 0; - for entry in WalkDir::new("../../../src") { - let entry = entry.unwrap(); - if entry.file_name() == "error_codes.rs" { - println!("cargo:rerun-if-changed={}", entry.path().to_str().unwrap()); - let file = fs::read_to_string(entry.path()).unwrap() - .replace("syntax::register_diagnostics!", "register_diagnostics!"); - let contents = format!("(|| {{\n{}\n}})()", file); - fs::write(&out_dir.join(&format!("error_{}.rs", idx)), &contents).unwrap(); + let error_codes_path = "../../../src/librustc_error_codes/error_codes.rs"; + + println!("cargo:rerun-if-changed={}", error_codes_path); + let file = fs::read_to_string(error_codes_path).unwrap() + .replace("crate::register_diagnostics!", "register_diagnostics!") + .replace(": include_str!(\"./error_codes/", ": include_str!(\"./"); + let contents = format!("(|| {{\n{}\n}})()", file); + fs::write(&out_dir.join("all_error_codes.rs"), &contents).unwrap(); - idx += 1; + // We copy the md files as well to the target directory. + for entry in WalkDir::new("../../../src/librustc_error_codes/error_codes") { + let entry = entry.unwrap(); + match entry.path().extension() { + Some(s) if s == "md" => {} + _ => continue, } + println!("cargo:rerun-if-changed={}", entry.path().to_str().unwrap()); + let md_content = fs::read_to_string(entry.path()).unwrap(); + fs::write(&out_dir.join(entry.file_name()), &md_content).unwrap(); } let mut all = String::new(); @@ -46,10 +53,7 @@ fn register_all() -> Vec<(&'static str, Option<&'static str>)> { ) } "###); - for idx in 0..idx { - all.push_str(&format!(r#"include!(concat!(env!("OUT_DIR"), "/error_{}.rs"));"#, idx)); - all.push_str("\n"); - } + all.push_str(r#"include!(concat!(env!("OUT_DIR"), "/all_error_codes.rs"));"#); all.push_str("\nlong_codes\n"); all.push_str("}\n"); |