diff --git a/src/librustc/diagnostics.rs b/src/librustc/diagnostics.rs index 91845e916d4d4..702df073092c3 100644 --- a/src/librustc/diagnostics.rs +++ b/src/librustc/diagnostics.rs @@ -1886,7 +1886,52 @@ This explicitly states that you expect the trait object `SomeTrait` to contain references (with a maximum lifetime of `'a`). [1]: https://github.com/rust-lang/rfcs/pull/1156 -"## +"##, + +E0454: r##" +A link name was given with an empty name. Erroneous code example: + +``` +#[link(name = "")] extern {} // error: #[link(name = "")] given with empty name +``` + +The rust compiler cannot link to an external library if you don't give it its +name. Example: + +``` +#[link(name = "some_lib")] extern {} // ok! +``` +"##, + +E0458: r##" +An unknown "kind" was specified for a link attribute. Erroneous code example: + +``` +#[link(kind = "wonderful_unicorn")] extern {} +// error: unknown kind: `wonderful_unicorn` +``` + +Please specify a valid "kind" value, from one of the following: + * static + * dylib + * framework +"##, + +E0459: r##" +A link was used without a name parameter. Erroneous code example: + +``` +#[link(kind = "dylib")] extern {} +// error: #[link(...)] specified without `name = "foo"` +``` + +Please add the name parameter to allow the rust compiler to find the library +you want. Example: + +``` +#[link(kind = "dylib", name = "some_lib")] extern {} // ok! +``` +"##, } @@ -1913,5 +1958,42 @@ register_diagnostics! { E0314, // closure outlives stack frame E0315, // cannot invoke closure outside of its lifetime E0316, // nested quantification of lifetimes - E0400 // overloaded derefs are not allowed in constants + E0400, // overloaded derefs are not allowed in constants + E0452, // malformed lint attribute + E0453, // overruled by outer forbid + E0455, // native frameworks are only available on OSX targets + 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 + E0463, // can't find crate for `..` + E0464, // multiple matching crates for `..` + E0465, // multiple .. candidates for `..` found + E0466, // bad macro import + E0467, // bad macro reexport + E0468, // an `extern crate` loading macros must be at the crate root + E0469, // imported macro not found + E0470, // reexported macro not found + E0471, // constant evaluation error: .. + 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... + E0478, // lifetime bound not satisfied + 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 + E0491, // in type `..`, reference has a longer lifetime than the data it... } diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index 67be93cc2bdc6..2cce9ef9145f6 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -467,7 +467,8 @@ impl<'a, 'tcx> Context<'a, 'tcx> { for result in gather_attrs(attrs) { let v = match result { Err(span) => { - self.tcx.sess.span_err(span, "malformed lint attribute"); + span_err!(self.tcx.sess, span, E0452, + "malformed lint attribute"); continue; } Ok((lint_name, level, span)) => { @@ -496,10 +497,10 @@ impl<'a, 'tcx> Context<'a, 'tcx> { let now = self.lints.get_level_source(lint_id).0; if now == Forbid && level != Forbid { let lint_name = lint_id.as_str(); - self.tcx.sess.span_err(span, - &format!("{}({}) overruled by outer forbid({})", - level.as_str(), lint_name, - lint_name)); + span_err!(self.tcx.sess, span, E0453, + "{}({}) overruled by outer forbid({})", + level.as_str(), lint_name, + lint_name); } else if now != level { let src = self.lints.get_level_source(lint_id).1; self.level_stack.push((lint_id, (now, src))); diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index 5ac84578369d2..c8298c3504c09 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -122,8 +122,8 @@ fn register_native_lib(sess: &Session, if name.is_empty() { match span { Some(span) => { - sess.span_err(span, "#[link(name = \"\")] given with \ - empty name"); + span_err!(sess, span, E0454, + "#[link(name = \"\")] given with empty name"); } None => { sess.err("empty library name given via `-l`"); @@ -135,7 +135,10 @@ fn register_native_lib(sess: &Session, if kind == cstore::NativeFramework && !is_osx { let msg = "native frameworks are only available on OSX targets"; match span { - Some(span) => sess.span_err(span, msg), + Some(span) => { + span_err!(sess, span, E0455, + "{}", msg) + } None => sess.err(msg), } } @@ -517,7 +520,7 @@ impl<'a> CrateReader<'a> { name, config::host_triple(), self.sess.opts.target_triple); - self.sess.span_err(span, &message[..]); + span_err!(self.sess, span, E0456, "{}", &message[..]); self.sess.abort_if_errors(); } @@ -527,10 +530,10 @@ impl<'a> CrateReader<'a> { match (ekrate.dylib.as_ref(), registrar) { (Some(dylib), Some(reg)) => Some((dylib.to_path_buf(), reg)), (None, Some(_)) => { - let message = format!("plugin `{}` only found in rlib format, \ - but must be available in dylib format", - name); - self.sess.span_err(span, &message[..]); + span_err!(self.sess, span, E0457, + "plugin `{}` only found in rlib format, but must be available \ + in dylib format", + name); // No need to abort because the loading code will just ignore this // empty dylib. None @@ -763,7 +766,8 @@ impl<'a, 'b> LocalCrateReader<'a, 'b> { Some("dylib") => cstore::NativeUnknown, Some("framework") => cstore::NativeFramework, Some(k) => { - self.sess.span_err(m.span, &format!("unknown kind: `{}`", k)); + span_err!(self.sess, m.span, E0458, + "unknown kind: `{}`", k); cstore::NativeUnknown } None => cstore::NativeUnknown @@ -774,8 +778,8 @@ impl<'a, 'b> LocalCrateReader<'a, 'b> { let n = match n { Some(n) => n, None => { - self.sess.span_err(m.span, "#[link(...)] specified without \ - `name = \"foo\"`"); + span_err!(self.sess, m.span, E0459, + "#[link(...)] specified without `name = \"foo\"`"); InternedString::new("foo") } }; diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index 2f481f70aafe9..99d1eaebdb251 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -308,23 +308,28 @@ impl<'a> Context<'a> { } pub fn report_load_errs(&mut self) { - let message = if !self.rejected_via_hash.is_empty() { - format!("found possibly newer version of crate `{}`", - self.ident) + let add = match self.root { + &None => String::new(), + &Some(ref r) => format!(" which `{}` depends on", + r.ident) + }; + if !self.rejected_via_hash.is_empty() { + span_err!(self.sess, self.span, E0460, + "found possibly newer version of crate `{}`{}", + self.ident, add); } else if !self.rejected_via_triple.is_empty() { - format!("couldn't find crate `{}` with expected target triple {}", - self.ident, self.triple) + span_err!(self.sess, self.span, E0461, + "couldn't find crate `{}` with expected target triple {}{}", + self.ident, self.triple, add); } else if !self.rejected_via_kind.is_empty() { - format!("found staticlib `{}` instead of rlib or dylib", self.ident) + span_err!(self.sess, self.span, E0462, + "found staticlib `{}` instead of rlib or dylib{}", + self.ident, add); } else { - format!("can't find crate for `{}`", self.ident) - }; - let message = match self.root { - &None => message, - &Some(ref r) => format!("{} which `{}` depends on", - message, r.ident) - }; - self.sess.span_err(self.span, &message[..]); + span_err!(self.sess, self.span, E0463, + "can't find crate for `{}`{}", + self.ident, add); + } if !self.rejected_via_triple.is_empty() { let mismatches = self.rejected_via_triple.iter(); @@ -473,9 +478,9 @@ impl<'a> Context<'a> { 0 => None, 1 => Some(libraries.into_iter().next().unwrap()), _ => { - self.sess.span_err(self.span, - &format!("multiple matching crates for `{}`", - self.crate_name)); + span_err!(self.sess, self.span, E0464, + "multiple matching crates for `{}`", + self.crate_name); self.sess.note("candidates:"); for lib in &libraries { match lib.dylib { @@ -543,11 +548,9 @@ impl<'a> Context<'a> { } }; if ret.is_some() { - self.sess.span_err(self.span, - &format!("multiple {} candidates for `{}` \ - found", - flavor, - self.crate_name)); + span_err!(self.sess, self.span, E0465, + "multiple {} candidates for `{}` found", + flavor, self.crate_name); self.sess.span_note(self.span, &format!(r"candidate #1: {}", ret.as_ref().unwrap().0 diff --git a/src/librustc/metadata/macro_import.rs b/src/librustc/metadata/macro_import.rs index 527f5919e2ddc..5105426392b2c 100644 --- a/src/librustc/metadata/macro_import.rs +++ b/src/librustc/metadata/macro_import.rs @@ -41,6 +41,10 @@ impl<'a> MacroLoader<'a> { } } +pub fn call_bad_macro_reexport(a: &Session, b: Span) { + span_err!(a, b, E0467, "bad macro reexport"); +} + /// Read exported macros. pub fn read_macro_defs(sess: &Session, krate: &ast::Crate) -> Vec { let mut loader = MacroLoader::new(sess); @@ -91,7 +95,7 @@ impl<'a, 'v> Visitor<'v> for MacroLoader<'a> { if let ast::MetaWord(ref name) = attr.node { sel.insert(name.clone(), attr.span); } else { - self.sess.span_err(attr.span, "bad macro import"); + span_err!(self.sess, attr.span, E0466, "bad macro import"); } } } @@ -100,7 +104,7 @@ impl<'a, 'v> Visitor<'v> for MacroLoader<'a> { let names = match attr.meta_item_list() { Some(names) => names, None => { - self.sess.span_err(attr.span, "bad macro reexport"); + call_bad_macro_reexport(self.sess, attr.span); continue; } }; @@ -109,7 +113,7 @@ impl<'a, 'v> Visitor<'v> for MacroLoader<'a> { if let ast::MetaWord(ref name) = attr.node { reexport.insert(name.clone(), attr.span); } else { - self.sess.span_err(attr.span, "bad macro reexport"); + call_bad_macro_reexport(self.sess, attr.span); } } } @@ -141,8 +145,8 @@ impl<'a> MacroLoader<'a> { } if !self.span_whitelist.contains(&vi.span) { - self.sess.span_err(vi.span, "an `extern crate` loading macros must be at \ - the crate root"); + span_err!(self.sess, vi.span, E0468, + "an `extern crate` loading macros must be at the crate root"); return; } @@ -167,14 +171,16 @@ impl<'a> MacroLoader<'a> { if let Some(sel) = import.as_ref() { for (name, span) in sel { if !seen.contains(&name) { - self.sess.span_err(*span, "imported macro not found"); + span_err!(self.sess, *span, E0469, + "imported macro not found"); } } } for (name, span) in &reexport { if !seen.contains(&name) { - self.sess.span_err(*span, "reexported macro not found"); + span_err!(self.sess, *span, E0470, + "reexported macro not found"); } } } diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 8d592c9262958..bf2d2fee20e5b 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -282,9 +282,9 @@ fn check_for_static_nan(cx: &MatchCheckCtxt, pat: &Pat) { Err(err) => { let subspan = p.span.lo <= err.span.lo && err.span.hi <= p.span.hi; - cx.tcx.sess.span_err(err.span, - &format!("constant evaluation error: {}", - err.description())); + span_err!(cx.tcx.sess, err.span, E0471, + "constant evaluation error: {}", + err.description()); if !subspan { cx.tcx.sess.span_note(p.span, "in pattern here") diff --git a/src/librustc/middle/check_no_asm.rs b/src/librustc/middle/check_no_asm.rs index aa1b7457aa90a..b9f8f20536a13 100644 --- a/src/librustc/middle/check_no_asm.rs +++ b/src/librustc/middle/check_no_asm.rs @@ -32,8 +32,8 @@ struct CheckNoAsm<'a> { impl<'a, 'v> Visitor<'v> for CheckNoAsm<'a> { fn visit_expr(&mut self, e: &ast::Expr) { match e.node { - ast::ExprInlineAsm(_) => self.sess.span_err(e.span, - "asm! is unsupported on this target"), + ast::ExprInlineAsm(_) => span_err!(self.sess, e.span, E0472, + "asm! is unsupported on this target"), _ => {}, } visit::walk_expr(self, e) diff --git a/src/librustc/middle/infer/error_reporting.rs b/src/librustc/middle/infer/error_reporting.rs index 7ec39ac851574..3d5c568ad312a 100644 --- a/src/librustc/middle/infer/error_reporting.rs +++ b/src/librustc/middle/infer/error_reporting.rs @@ -717,20 +717,17 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { ""); } infer::DerefPointer(span) => { - self.tcx.sess.span_err( - span, - "dereference of reference outside its lifetime"); + span_err!(self.tcx.sess, span, E0473, + "dereference of reference outside its lifetime"); self.tcx.note_and_explain_region( "the reference is only valid for ", sup, ""); } infer::FreeVariable(span, id) => { - self.tcx.sess.span_err( - span, - &format!("captured variable `{}` does not \ - outlive the enclosing closure", - self.tcx.local_var_name_str(id))); + span_err!(self.tcx.sess, span, E0474, + "captured variable `{}` does not outlive the enclosing closure", + self.tcx.local_var_name_str(id)); self.tcx.note_and_explain_region( "captured variable is valid for ", sup, @@ -741,18 +738,17 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { ""); } infer::IndexSlice(span) => { - self.tcx.sess.span_err(span, - "index of slice outside its lifetime"); + span_err!(self.tcx.sess, span, E0475, + "index of slice outside its lifetime"); self.tcx.note_and_explain_region( "the slice is only valid for ", sup, ""); } infer::RelateObjectBound(span) => { - self.tcx.sess.span_err( - span, - "lifetime of the source pointer does not outlive \ - lifetime bound of the object type"); + span_err!(self.tcx.sess, span, E0476, + "lifetime of the source pointer does not outlive \ + lifetime bound of the object type"); self.tcx.note_and_explain_region( "object type is valid for ", sub, @@ -763,20 +759,17 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { ""); } infer::RelateParamBound(span, ty) => { - self.tcx.sess.span_err( - span, - &format!("the type `{}` does not fulfill the \ - required lifetime", - self.ty_to_string(ty))); + span_err!(self.tcx.sess, span, E0477, + "the type `{}` does not fulfill the required lifetime", + self.ty_to_string(ty)); self.tcx.note_and_explain_region( "type must outlive ", sub, ""); } infer::RelateRegionParamBound(span) => { - self.tcx.sess.span_err( - span, - "lifetime bound not satisfied"); + span_err!(self.tcx.sess, span, E0478, + "lifetime bound not satisfied"); self.tcx.note_and_explain_region( "lifetime parameter instantiated with ", sup, @@ -787,92 +780,82 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { ""); } infer::RelateDefaultParamBound(span, ty) => { - self.tcx.sess.span_err( - span, - &format!("the type `{}` (provided as the value of \ - a type parameter) is not valid at this point", - self.ty_to_string(ty))); + span_err!(self.tcx.sess, span, E0479, + "the type `{}` (provided as the value of \ + a type parameter) is not valid at this point", + self.ty_to_string(ty)); self.tcx.note_and_explain_region( "type must outlive ", sub, ""); } infer::CallRcvr(span) => { - self.tcx.sess.span_err( - span, - "lifetime of method receiver does not outlive \ - the method call"); + span_err!(self.tcx.sess, span, E0480, + "lifetime of method receiver does not outlive \ + the method call"); self.tcx.note_and_explain_region( "the receiver is only valid for ", sup, ""); } infer::CallArg(span) => { - self.tcx.sess.span_err( - span, - "lifetime of function argument does not outlive \ - the function call"); + span_err!(self.tcx.sess, span, E0481, + "lifetime of function argument does not outlive \ + the function call"); self.tcx.note_and_explain_region( "the function argument is only valid for ", sup, ""); } infer::CallReturn(span) => { - self.tcx.sess.span_err( - span, - "lifetime of return value does not outlive \ - the function call"); + span_err!(self.tcx.sess, span, E0482, + "lifetime of return value does not outlive \ + the function call"); self.tcx.note_and_explain_region( "the return value is only valid for ", sup, ""); } infer::Operand(span) => { - self.tcx.sess.span_err( - span, - "lifetime of operand does not outlive \ - the operation"); + span_err!(self.tcx.sess, span, E0483, + "lifetime of operand does not outlive \ + the operation"); self.tcx.note_and_explain_region( "the operand is only valid for ", sup, ""); } infer::AddrOf(span) => { - self.tcx.sess.span_err( - span, - "reference is not valid \ - at the time of borrow"); + span_err!(self.tcx.sess, span, E0484, + "reference is not valid at the time of borrow"); self.tcx.note_and_explain_region( "the borrow is only valid for ", sup, ""); } infer::AutoBorrow(span) => { - self.tcx.sess.span_err( - span, - "automatically reference is not valid \ - at the time of borrow"); + span_err!(self.tcx.sess, span, E0485, + "automatically reference is not valid \ + at the time of borrow"); self.tcx.note_and_explain_region( "the automatic borrow is only valid for ", sup, ""); } infer::ExprTypeIsNotInScope(t, span) => { - self.tcx.sess.span_err( - span, - &format!("type of expression contains references \ - that are not valid during the expression: `{}`", - self.ty_to_string(t))); + span_err!(self.tcx.sess, span, E0486, + "type of expression contains references \ + that are not valid during the expression: `{}`", + self.ty_to_string(t)); self.tcx.note_and_explain_region( "type is only valid for ", sup, ""); } infer::SafeDestructor(span) => { - self.tcx.sess.span_err( - span, - "unsafe use of destructor: destructor might be called \ - while references are dead"); + span_err!(self.tcx.sess, span, E0487, + "unsafe use of destructor: destructor might be called \ + while references are dead"); // FIXME (22171): terms "super/subregion" are suboptimal self.tcx.note_and_explain_region( "superregion: ", @@ -884,37 +867,33 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { ""); } infer::BindingTypeIsNotValidAtDecl(span) => { - self.tcx.sess.span_err( - span, - "lifetime of variable does not enclose its declaration"); + span_err!(self.tcx.sess, span, E0488, + "lifetime of variable does not enclose its declaration"); self.tcx.note_and_explain_region( "the variable is only valid for ", sup, ""); } infer::ParameterInScope(_, span) => { - self.tcx.sess.span_err( - span, - &format!("type/lifetime parameter not in scope here")); + span_err!(self.tcx.sess, span, E0489, + "type/lifetime parameter not in scope here"); self.tcx.note_and_explain_region( "the parameter is only valid for ", sub, ""); } infer::DataBorrowed(ty, span) => { - self.tcx.sess.span_err( - span, - &format!("a value of type `{}` is borrowed for too long", - self.ty_to_string(ty))); + span_err!(self.tcx.sess, span, E0490, + "a value of type `{}` is borrowed for too long", + self.ty_to_string(ty)); self.tcx.note_and_explain_region("the type is valid for ", sub, ""); self.tcx.note_and_explain_region("but the borrow lasts for ", sup, ""); } infer::ReferenceOutlivesReferent(ty, span) => { - self.tcx.sess.span_err( - span, - &format!("in type `{}`, reference has a longer lifetime \ - than the data it references", - self.ty_to_string(ty))); + span_err!(self.tcx.sess, span, E0491, + "in type `{}`, reference has a longer lifetime \ + than the data it references", + self.ty_to_string(ty)); self.tcx.note_and_explain_region( "the pointer is valid for ", sub, @@ -1778,7 +1757,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { "...so that return value is valid for the call"); } infer::Operand(span) => { - self.tcx.sess.span_err( + self.tcx.sess.span_note( span, "...so that operand is valid for operation"); }