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>
This commit is contained in:
bors
commit
82cf3a4486
19
Cargo.lock
19
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",
|
||||
@ -3516,6 +3519,10 @@ dependencies = [
|
||||
"syntax_pos",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rustc_error_codes"
|
||||
version = "0.0.0"
|
||||
|
||||
[[package]]
|
||||
name = "rustc_errors"
|
||||
version = "0.0.0"
|
||||
@ -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",
|
||||
|
||||
@ -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" }
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -16,6 +16,8 @@
|
||||
use syntax::{attr, symbol::sym};
|
||||
use syntax_pos::Span;
|
||||
|
||||
use rustc_error_codes::*;
|
||||
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
pub(crate) enum MethodKind {
|
||||
Trait { body: bool },
|
||||
|
||||
@ -74,6 +74,8 @@
|
||||
use syntax_pos::hygiene::ExpnId;
|
||||
use syntax_pos::Span;
|
||||
|
||||
use rustc_error_codes::*;
|
||||
|
||||
const HIR_ID_COUNTER_LOCKED: u32 = 0xFFFFFFFF;
|
||||
|
||||
pub struct LoweringContext<'a> {
|
||||
|
||||
@ -11,6 +11,8 @@
|
||||
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()
|
||||
|
||||
@ -23,6 +23,8 @@
|
||||
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>,
|
||||
}
|
||||
|
||||
@ -63,6 +63,8 @@
|
||||
use std::{cmp, fmt};
|
||||
use syntax_pos::{Pos, Span};
|
||||
|
||||
use rustc_error_codes::*;
|
||||
|
||||
mod note;
|
||||
|
||||
mod need_type_info;
|
||||
|
||||
@ -9,6 +9,8 @@
|
||||
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>,
|
||||
|
||||
@ -5,6 +5,8 @@
|
||||
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.
|
||||
///
|
||||
|
||||
@ -5,6 +5,8 @@
|
||||
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.
|
||||
|
||||
@ -4,6 +4,8 @@
|
||||
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<'_>,
|
||||
|
||||
@ -15,6 +15,8 @@
|
||||
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
|
||||
|
||||
@ -83,8 +83,6 @@
|
||||
#[macro_use]
|
||||
mod macros;
|
||||
|
||||
pub mod error_codes;
|
||||
|
||||
#[macro_use]
|
||||
pub mod query;
|
||||
|
||||
|
||||
@ -40,6 +40,8 @@
|
||||
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
|
||||
|
||||
@ -16,6 +16,8 @@
|
||||
use syntax::source_map::MultiSpan;
|
||||
use syntax::symbol::{Symbol, sym};
|
||||
|
||||
use rustc_error_codes::*;
|
||||
|
||||
pub struct LintLevelSets {
|
||||
list: Vec<LintSet>,
|
||||
lint_cap: Level,
|
||||
|
||||
@ -23,6 +23,8 @@
|
||||
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 {
|
||||
|
||||
@ -11,7 +11,8 @@
|
||||
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 @@ fn collect_feature(&mut self, feature: Symbol, since: Option<Symbol>, span: Span
|
||||
(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 @@ fn collect_feature(&mut self, feature: Symbol, since: Option<Symbol>, span: Span
|
||||
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> {
|
||||
|
||||
@ -30,6 +30,8 @@
|
||||
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.
|
||||
|
||||
@ -26,6 +26,9 @@
|
||||
use std::mem::replace;
|
||||
use std::num::NonZeroU32;
|
||||
|
||||
use rustc_error_codes::*;
|
||||
|
||||
|
||||
#[derive(PartialEq, Clone, Copy, Debug)]
|
||||
pub enum StabilityLevel {
|
||||
Unstable,
|
||||
|
||||
@ -14,6 +14,8 @@
|
||||
use crate::hir;
|
||||
use crate::ty::TyCtxt;
|
||||
|
||||
use rustc_error_codes::*;
|
||||
|
||||
macro_rules! weak_lang_items {
|
||||
($($name:ident, $item:ident, $sym:ident;)*) => (
|
||||
|
||||
|
||||
@ -16,6 +16,8 @@
|
||||
|
||||
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.
|
||||
|
||||
@ -39,6 +39,8 @@
|
||||
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,
|
||||
|
||||
@ -10,6 +10,8 @@
|
||||
use syntax::symbol::{Symbol, kw, sym};
|
||||
use syntax_pos::Span;
|
||||
|
||||
use rustc_error_codes::*;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct OnUnimplementedFormatString(Symbol);
|
||||
|
||||
|
||||
@ -6,6 +6,8 @@
|
||||
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
|
||||
|
||||
@ -24,6 +24,8 @@
|
||||
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 {
|
||||
|
||||
@ -26,6 +26,8 @@
|
||||
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>>,
|
||||
|
||||
@ -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" }
|
||||
|
||||
@ -12,6 +12,8 @@
|
||||
use rustc::hir;
|
||||
use crate::traits::BuilderMethods;
|
||||
|
||||
use rustc_error_codes::*;
|
||||
|
||||
pub enum IntPredicate {
|
||||
IntEQ,
|
||||
IntNE,
|
||||
|
||||
@ -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.
|
||||
"##,
|
||||
|
||||
}
|
||||
@ -35,8 +35,6 @@
|
||||
use rustc::middle::dependency_format::Dependencies;
|
||||
use syntax_pos::symbol::Symbol;
|
||||
|
||||
mod error_codes;
|
||||
|
||||
pub mod common;
|
||||
pub mod traits;
|
||||
pub mod mir;
|
||||
|
||||
@ -6,6 +6,8 @@
|
||||
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,
|
||||
|
||||
@ -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 {
|
||||
|
||||
9
src/librustc_error_codes/Cargo.toml
Normal file
9
src/librustc_error_codes/Cargo.toml
Normal file
@ -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"
|
||||
609
src/librustc_error_codes/error_codes.rs
Normal file
609
src/librustc_error_codes/error_codes.rs
Normal file
@ -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
|
||||
}
|
||||
24
src/librustc_error_codes/error_codes/E0001.md
Normal file
24
src/librustc_error_codes/error_codes/E0001.md
Normal file
@ -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.
|
||||
29
src/librustc_error_codes/error_codes/E0002.md
Normal file
29
src/librustc_error_codes/error_codes/E0002.md
Normal file
@ -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
|
||||
}
|
||||
}
|
||||
```
|
||||
46
src/librustc_error_codes/error_codes/E0004.md
Normal file
46
src/librustc_error_codes/error_codes/E0004.md
Normal file
@ -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 => {}
|
||||
_ => {}
|
||||
}
|
||||
```
|
||||
30
src/librustc_error_codes/error_codes/E0005.md
Normal file
30
src/librustc_error_codes/error_codes/E0005.md
Normal file
@ -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
|
||||
}
|
||||
```
|
||||
18
src/librustc_error_codes/error_codes/E0007.md
Normal file
18
src/librustc_error_codes/error_codes/E0007.md
Normal file
@ -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.
|
||||
48
src/librustc_error_codes/error_codes/E0009.md
Normal file
48
src/librustc_error_codes/error_codes/E0009.md
Normal file
@ -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!()
|
||||
}
|
||||
```
|
||||
11
src/librustc_error_codes/error_codes/E0010.md
Normal file
11
src/librustc_error_codes/error_codes/E0010.md
Normal file
@ -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;
|
||||
```
|
||||
18
src/librustc_error_codes/error_codes/E0013.md
Normal file
18
src/librustc_error_codes/error_codes/E0013.md
Normal file
@ -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;
|
||||
```
|
||||
20
src/librustc_error_codes/error_codes/E0014.md
Normal file
20
src/librustc_error_codes/error_codes/E0014.md
Normal file
@ -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
|
||||
```
|
||||
14
src/librustc_error_codes/error_codes/E0015.md
Normal file
14
src/librustc_error_codes/error_codes/E0015.md
Normal file
@ -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
|
||||
20
src/librustc_error_codes/error_codes/E0017.md
Normal file
20
src/librustc_error_codes/error_codes/E0017.md
Normal file
@ -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`.
|
||||
36
src/librustc_error_codes/error_codes/E0019.md
Normal file
36
src/librustc_error_codes/error_codes/E0019.md
Normal file
@ -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!
|
||||
}
|
||||
```
|
||||
47
src/librustc_error_codes/error_codes/E0023.md
Normal file
47
src/librustc_error_codes/error_codes/E0023.md
Normal file
@ -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.
|
||||
33
src/librustc_error_codes/error_codes/E0025.md
Normal file
33
src/librustc_error_codes/error_codes/E0025.md
Normal file
@ -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!
|
||||
}
|
||||
```
|
||||
51
src/librustc_error_codes/error_codes/E0026.md
Normal file
51
src/librustc_error_codes/error_codes/E0026.md
Normal file
@ -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 } => {}
|
||||
}
|
||||
```
|
||||
39
src/librustc_error_codes/error_codes/E0027.md
Normal file
39
src/librustc_error_codes/error_codes/E0027.md
Normal file
@ -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, .. } => {}
|
||||
}
|
||||
```
|
||||
22
src/librustc_error_codes/error_codes/E0029.md
Normal file
22
src/librustc_error_codes/error_codes/E0029.md
Normal file
@ -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" => {}
|
||||
_ => {}
|
||||
}
|
||||
```
|
||||
15
src/librustc_error_codes/error_codes/E0030.md
Normal file
15
src/librustc_error_codes/error_codes/E0030.md
Normal file
@ -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 => {}
|
||||
}
|
||||
```
|
||||
23
src/librustc_error_codes/error_codes/E0033.md
Normal file
23
src/librustc_error_codes/error_codes/E0033.md
Normal file
@ -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
|
||||
84
src/librustc_error_codes/error_codes/E0034.md
Normal file
84
src/librustc_error_codes/error_codes/E0034.md
Normal file
@ -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"
|
||||
}
|
||||
```
|
||||
291
src/librustc_error_codes/error_codes/E0038.md
Normal file
291
src/librustc_error_codes/error_codes/E0038.md
Normal file
@ -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>`.
|
||||
22
src/librustc_error_codes/error_codes/E0040.md
Normal file
22
src/librustc_error_codes/error_codes/E0040.md
Normal file
@ -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
|
||||
}
|
||||
```
|
||||
14
src/librustc_error_codes/error_codes/E0044.md
Normal file
14
src/librustc_error_codes/error_codes/E0044.md
Normal file
@ -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); }
|
||||
```
|
||||
21
src/librustc_error_codes/error_codes/E0045.md
Normal file
21
src/librustc_error_codes/error_codes/E0045.md
Normal file
@ -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, ...);
|
||||
}
|
||||
```
|
||||
29
src/librustc_error_codes/error_codes/E0046.md
Normal file
29
src/librustc_error_codes/error_codes/E0046.md
Normal file
@ -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!
|
||||
}
|
||||
```
|
||||
19
src/librustc_error_codes/error_codes/E0049.md
Normal file
19
src/librustc_error_codes/error_codes/E0049.md
Normal file
@ -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 }
|
||||
}
|
||||
```
|
||||
20
src/librustc_error_codes/error_codes/E0050.md
Normal file
20
src/librustc_error_codes/error_codes/E0050.md
Normal file
@ -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 }
|
||||
}
|
||||
```
|
||||
21
src/librustc_error_codes/error_codes/E0053.md
Normal file
21
src/librustc_error_codes/error_codes/E0053.md
Normal file
@ -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) { }
|
||||
}
|
||||
```
|
||||
16
src/librustc_error_codes/error_codes/E0054.md
Normal file
16
src/librustc_error_codes/error_codes/E0054.md
Normal file
@ -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;
|
||||
```
|
||||
28
src/librustc_error_codes/error_codes/E0055.md
Normal file
28
src/librustc_error_codes/error_codes/E0055.md
Normal file
@ -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.
|
||||
20
src/librustc_error_codes/error_codes/E0057.md
Normal file
20
src/librustc_error_codes/error_codes/E0057.md
Normal file
@ -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
|
||||
}
|
||||
```
|
||||
25
src/librustc_error_codes/error_codes/E0059.md
Normal file
25
src/librustc_error_codes/error_codes/E0059.md
Normal file
@ -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.
|
||||
36
src/librustc_error_codes/error_codes/E0060.md
Normal file
36
src/librustc_error_codes/error_codes/E0060.md
Normal file
@ -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);
|
||||
}
|
||||
# }
|
||||
```
|
||||
13
src/librustc_error_codes/error_codes/E0061.md
Normal file
13
src/librustc_error_codes/error_codes/E0061.md
Normal file
@ -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).
|
||||
28
src/librustc_error_codes/error_codes/E0062.md
Normal file
28
src/librustc_error_codes/error_codes/E0062.md
Normal file
@ -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!
|
||||
}
|
||||
```
|
||||
26
src/librustc_error_codes/error_codes/E0063.md
Normal file
26
src/librustc_error_codes/error_codes/E0063.md
Normal file
@ -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!
|
||||
}
|
||||
```
|
||||
33
src/librustc_error_codes/error_codes/E0067.md
Normal file
33
src/librustc_error_codes/error_codes/E0067.md
Normal file
@ -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 !
|
||||
}
|
||||
```
|
||||
12
src/librustc_error_codes/error_codes/E0069.md
Normal file
12
src/librustc_error_codes/error_codes/E0069.md
Normal file
@ -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.
|
||||
47
src/librustc_error_codes/error_codes/E0070.md
Normal file
47
src/librustc_error_codes/error_codes/E0070.md
Normal file
@ -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 !
|
||||
}
|
||||
```
|
||||
27
src/librustc_error_codes/error_codes/E0071.md
Normal file
27
src/librustc_error_codes/error_codes/E0071.md
Normal file
@ -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;
|
||||
}
|
||||
```
|
||||
34
src/librustc_error_codes/error_codes/E0072.md
Normal file
34
src/librustc_error_codes/error_codes/E0072.md
Normal file
@ -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.
|
||||
19
src/librustc_error_codes/error_codes/E0073.md
Normal file
19
src/librustc_error_codes/error_codes/E0073.md
Normal file
@ -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 }`.
|
||||
24
src/librustc_error_codes/error_codes/E0074.md
Normal file
24
src/librustc_error_codes/error_codes/E0074.md
Normal file
@ -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);
|
||||
```
|
||||
21
src/librustc_error_codes/error_codes/E0075.md
Normal file
21
src/librustc_error_codes/error_codes/E0075.md
Normal file
@ -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);
|
||||
```
|
||||
21
src/librustc_error_codes/error_codes/E0076.md
Normal file
21
src/librustc_error_codes/error_codes/E0076.md
Normal file
@ -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);
|
||||
```
|
||||
20
src/librustc_error_codes/error_codes/E0077.md
Normal file
20
src/librustc_error_codes/error_codes/E0077.md
Normal file
@ -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);
|
||||
```
|
||||
16
src/librustc_error_codes/error_codes/E0080.md
Normal file
16
src/librustc_error_codes/error_codes/E0080.md
Normal file
@ -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
|
||||
35
src/librustc_error_codes/error_codes/E0081.md
Normal file
35
src/librustc_error_codes/error_codes/E0081.md
Normal file
@ -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.
|
||||
27
src/librustc_error_codes/error_codes/E0084.md
Normal file
27
src/librustc_error_codes/error_codes/E0084.md
Normal file
@ -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 {}
|
||||
```
|
||||
15
src/librustc_error_codes/error_codes/E0087.md
Normal file
15
src/librustc_error_codes/error_codes/E0087.md
Normal file
@ -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.
|
||||
45
src/librustc_error_codes/error_codes/E0088.md
Normal file
45
src/librustc_error_codes/error_codes/E0088.md
Normal file
@ -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());
|
||||
}
|
||||
```
|
||||
25
src/librustc_error_codes/error_codes/E0089.md
Normal file
25
src/librustc_error_codes/error_codes/E0089.md
Normal file
@ -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)`
|
||||
}
|
||||
```
|
||||
22
src/librustc_error_codes/error_codes/E0090.md
Normal file
22
src/librustc_error_codes/error_codes/E0090.md
Normal file
@ -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>();
|
||||
}
|
||||
```
|
||||
15
src/librustc_error_codes/error_codes/E0091.md
Normal file
15
src/librustc_error_codes/error_codes/E0091.md
Normal file
@ -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!
|
||||
```
|
||||
23
src/librustc_error_codes/error_codes/E0092.md
Normal file
23
src/librustc_error_codes/error_codes/E0092.md
Normal file
@ -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!
|
||||
}
|
||||
```
|
||||
33
src/librustc_error_codes/error_codes/E0093.md
Normal file
33
src/librustc_error_codes/error_codes/E0093.md
Normal file
@ -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();
|
||||
}
|
||||
}
|
||||
```
|
||||
23
src/librustc_error_codes/error_codes/E0094.md
Normal file
23
src/librustc_error_codes/error_codes/E0094.md
Normal file
@ -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!
|
||||
}
|
||||
```
|
||||
53
src/librustc_error_codes/error_codes/E0106.md
Normal file
53
src/librustc_error_codes/error_codes/E0106.md
Normal file
@ -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
|
||||
28
src/librustc_error_codes/error_codes/E0107.md
Normal file
28
src/librustc_error_codes/error_codes/E0107.md
Normal file
@ -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
|
||||
}
|
||||
```
|
||||
|
||||
21
src/librustc_error_codes/error_codes/E0109.md
Normal file
21
src/librustc_error_codes/error_codes/E0109.md
Normal file
@ -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`.
|
||||
4
src/librustc_error_codes/error_codes/E0110.md
Normal file
4
src/librustc_error_codes/error_codes/E0110.md
Normal file
@ -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.
|
||||
23
src/librustc_error_codes/error_codes/E0116.md
Normal file
23
src/librustc_error_codes/error_codes/E0116.md
Normal file
@ -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
|
||||
```
|
||||
48
src/librustc_error_codes/error_codes/E0117.md
Normal file
48
src/librustc_error_codes/error_codes/E0117.md
Normal file
@ -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
|
||||
41
src/librustc_error_codes/error_codes/E0118.md
Normal file
41
src/librustc_error_codes/error_codes/E0118.md
Normal file
@ -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()
|
||||
}
|
||||
}
|
||||
```
|
||||
58
src/librustc_error_codes/error_codes/E0119.md
Normal file
58
src/librustc_error_codes/error_codes/E0119.md
Normal file
@ -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
|
||||
}
|
||||
```
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user