```
"##,
+E0493: r##"
+A type with a destructor was assigned to an invalid type of variable. Erroneous
+code example:
+
+```
+struct Foo {
+ a: u32
+}
+
+impl Drop for Foo {
+ fn drop(&mut self) {}
+}
+
+const F : Foo = Foo { a : 0 };
+// error: constants are not allowed to have destructors
+static S : Foo = Foo { a : 0 };
+// error: statics are not allowed to have destructors
+```
+
+To solve this issue, please use a type which does allow the usage of type with
+destructors.
+"##,
+
+E0494: r##"
+A reference of an interior static was assigned to another const/static.
+Erroneous code example:
+
+```
+struct Foo {
+ a: u32
+}
+
+static S : Foo = Foo { a : 0 };
+static A : &'static u32 = &S.a;
+// error: cannot refer to the interior of another static, use a
+// constant instead
+```
+
+The "base" variable has to be a const if you want another static/const variable
+to refer to one of its fields. Example:
+
+```
+struct Foo {
+ a: u32
+}
+
+const S : Foo = Foo { a : 0 };
+static A : &'static u32 = &S.a; // ok!
+```
+"##,
+
+E0497: r##"
+A stability attribute was used outside of the standard library. Erroneous code
+example:
+
+```
+#[stable] // error: stability attributes may not be used outside of the
+ // standard library
+fn foo() {}
+```
+
+It is not possible to use stability attributes outside of the standard library.
+Also, for now, it is not possible to write deprecation messages either.
+"##,
+
}
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...
+ E0492, // cannot borrow a constant which contains interior mutability
+ E0495, // cannot infer an appropriate lifetime due to conflicting requirements
+ E0496, // .. name `..` shadows a .. name that is already in scope
+ E0498, // malformed plugin attribute
}
if self.qualif.intersects(ConstQualif::MUTABLE_MEM) && tc.interior_unsafe() {
outer = outer | ConstQualif::NOT_CONST;
if self.mode != Mode::Var {
- self.tcx.sess.span_err(ex.span,
- "cannot borrow a constant which contains \
- interior mutability, create a static instead");
+ span_err!(self.tcx.sess, ex.span, E0492,
+ "cannot borrow a constant which contains \
+ interior mutability, create a static instead");
}
}
// If the reference has to be 'static, avoid in-place initialization
ty::TyEnum(def, _) if def.has_dtor() => {
v.add_qualif(ConstQualif::NEEDS_DROP);
if v.mode != Mode::Var {
- v.tcx.sess.span_err(e.span,
- &format!("{}s are not allowed to have destructors",
- v.msg()));
+ span_err!(v.tcx.sess, e.span, E0493,
+ "{}s are not allowed to have destructors",
+ v.msg());
}
}
_ => {}
// Borrowed statics can specifically *only* have their address taken,
// not any number of other borrows such as borrowing fields, reading
// elements of an array, etc.
- self.tcx.sess.span_err(borrow_span,
- "cannot refer to the interior of another \
- static, use a constant instead");
+ span_err!(self.tcx.sess, borrow_span, E0494,
+ "cannot refer to the interior of another \
+ static, use a constant instead");
}
break;
}
}
};
- self.tcx.sess.span_err(
- var_origin.span(),
- &format!("cannot infer an appropriate lifetime{} \
- due to conflicting requirements",
- var_description));
+ span_err!(self.tcx.sess, var_origin.span(), E0495,
+ "cannot infer an appropriate lifetime{} \
+ due to conflicting requirements",
+ var_description);
}
fn note_region_origin(&self, origin: &SubregionOrigin<'tcx>) {
sess: &Session, name: ast::Name, orig: Original, shadower: Shadower) {
if let (ShadowKind::Lifetime, ShadowKind::Lifetime) = (orig.kind, shadower.kind) {
// lifetime/lifetime shadowing is an error
- sess.span_err(shadower.span,
- &format!("{} name `{}` shadows a \
- {} name that is already in scope",
- shadower.kind.desc(), name, orig.kind.desc()));
+ span_err!(sess, shadower.span, E0496,
+ "{} name `{}` shadows a \
+ {} name that is already in scope",
+ shadower.kind.desc(), name, orig.kind.desc());
} else {
// shadowing involving a label is only a warning, due to issues with
// labels and lifetimes not being macro-hygienic.
plugins: Vec<PluginRegistrar>,
}
+fn call_malformed_plugin_attribute(a: &Session, b: Span) {
+ span_err!(a, b, E0498, "malformed plugin attribute");
+}
+
/// Read plugin metadata and dynamically load registrar functions.
pub fn load_plugins(sess: &Session, krate: &ast::Crate,
addl_plugins: Option<Vec<String>>) -> Vec<PluginRegistrar> {
let plugins = match attr.meta_item_list() {
Some(xs) => xs,
None => {
- sess.span_err(attr.span, "malformed plugin attribute");
+ call_malformed_plugin_attribute(sess, attr.span);
continue;
}
};
for plugin in plugins {
if plugin.value_str().is_some() {
- sess.span_err(attr.span, "malformed plugin attribute");
+ call_malformed_plugin_attribute(sess, attr.span);
continue;
}