let mut checked = false;
opt_place.as_ref().map(|place| match place.node {
ast::ExprPath(None, ref path) => {
- // FIXME(pcwalton): For now we hardcode the two permissible
- // places: the exchange heap and the managed heap.
+ // FIXME(pcwalton): For now we hardcode the only permissible
+ // place: the exchange heap.
let definition = lookup_full_def(tcx, path.span, place.id);
let def_id = definition.def_id();
let referent_ty = fcx.expr_ty(&**subexpr);
if !checked {
span_err!(tcx.sess, expr.span, E0066,
- "only the managed heap and exchange heap are currently supported");
+ "only the exchange heap is currently supported");
fcx.write_ty(id, tcx.types.err);
}
}
if let Err(_) = fcx.mk_eqty(false, infer::Misc(expr.span),
result_type, ty::mk_nil(fcx.tcx())) {
span_err!(tcx.sess, expr.span, E0069,
- "`return;` in function returning non-nil");
+ "`return;` in a function whose return type is \
+ not `()`");
},
Some(ref e) => {
check_expr_coercable_to_type(fcx, &**e, result_type);
exactly once.
"##,
+E0066: r##"
+Box placement expressions (like C++'s "placement new") do not support any
+place expression except the exchange heap (i.e. `std::boxed::HEAP`).
+Furthermore, the syntax is changing to use `in` instead of `box`. See [RFC
+470][rfc470] and [RFC 809][rfc809] for more details.
+
+[rfc470]: https://github.com/rust-lang/rfcs/pull/470
+[rfc809]: https://github.com/rust-lang/rfcs/pull/809
+"##,
+
E0067: r##"
The left-hand side of an assignment operator must be an lvalue expression. An
lvalue expression represents a memory location and includes item paths (ie,
```
"##,
+E0069: r##"
+The compiler found a function whose body contains a `return;` statement but
+whose return type is not `()`. An example of this is:
+
+```
+// 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.
+"##,
+
E0081: r##"
Enum discriminants are used to differentiate enum variants stored in memory.
This error indicates that the same value was used for two or more variants,
E0059,
E0060,
E0061,
- E0066,
E0068,
- E0069,
E0070,
E0071,
E0072,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern: `return;` in function returning non-nil
+// error-pattern: `return;` in a function whose return type is not `()`
fn f() { return; }