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!
+```
+"##,
}
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...
}
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)) => {
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)));
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`");
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),
}
}
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();
}
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
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
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")
}
};
}
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();
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 {
}
};
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
}
}
+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<ast::MacroDef> {
let mut loader = MacroLoader::new(sess);
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");
}
}
}
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;
}
};
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);
}
}
}
}
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;
}
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");
}
}
}
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")
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)
"");
}
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,
"");
}
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,
"");
}
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,
"");
}
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: ",
"");
}
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,
"...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");
}
projects / rust.git / commitdiff