use session::Session;
use {CrateCtxt, lookup_def_ccx, no_params, require_same_types};
use TypeAndSubsts;
-use middle::lang_items::TypeIdLangItem;
use lint;
use util::common::{block_query, indenter, loop_query};
use util::ppaux::{self, Repr};
-> Inherited<'a, 'tcx> {
Inherited {
infcx: infer::new_infer_ctxt(tcx),
- locals: RefCell::new(NodeMap::new()),
+ locals: RefCell::new(NodeMap()),
param_env: param_env,
- node_types: RefCell::new(NodeMap::new()),
- item_substs: RefCell::new(NodeMap::new()),
- adjustments: RefCell::new(NodeMap::new()),
- method_map: RefCell::new(FnvHashMap::new()),
- object_cast_map: RefCell::new(NodeMap::new()),
- upvar_borrow_map: RefCell::new(FnvHashMap::new()),
- unboxed_closures: RefCell::new(DefIdMap::new()),
- fn_sig_map: RefCell::new(NodeMap::new()),
+ node_types: RefCell::new(NodeMap()),
+ item_substs: RefCell::new(NodeMap()),
+ adjustments: RefCell::new(NodeMap()),
+ method_map: RefCell::new(FnvHashMap()),
+ object_cast_map: RefCell::new(NodeMap()),
+ upvar_borrow_map: RefCell::new(FnvHashMap()),
+ unboxed_closures: RefCell::new(DefIdMap()),
+ fn_sig_map: RefCell::new(NodeMap()),
fulfillment_cx: RefCell::new(traits::FulfillmentContext::new()),
}
}
}) {
Some(_) => (),
None => {
- ccx.tcx.sess.span_err(attr.span,
- format!("there is no type parameter \
+ span_err!(ccx.tcx.sess, attr.span, E0230,
+ "there is no type parameter \
{} on trait {}",
- s, item.ident.as_str())
- .as_slice());
+ s, item.ident.as_str());
}
},
// `{:1}` and `{}` are not to be used
Position::ArgumentIs(_) | Position::ArgumentNext => {
- ccx.tcx.sess.span_err(attr.span,
+ span_err!(ccx.tcx.sess, attr.span, E0231,
"only named substitution \
parameters are allowed");
}
}
}
} else {
- ccx.tcx.sess.span_err(attr.span,
+ span_err!(ccx.tcx.sess, attr.span, E0232,
"this attribute must have a value, \
eg `#[rustc_on_unimplemented = \"foo\"]`")
}
{
debug!("register_predicate({})",
obligation.repr(self.tcx()));
-
self.inh.fulfillment_cx
.borrow_mut()
.register_predicate_obligation(self.infcx(), obligation);
let trait_did = match fcx.tcx().lang_items.require(IteratorItem) {
Ok(trait_did) => trait_did,
Err(ref err_string) => {
- fcx.tcx().sess.span_err(iterator_expr.span,
- &err_string[]);
+ span_err!(fcx.tcx().sess, iterator_expr.span, E0233,
+ "{}", &err_string[]);
return fcx.tcx().types.err
}
};
if !ty::type_is_error(true_expr_type) {
let ty_string = fcx.infcx().ty_to_string(true_expr_type);
- fcx.tcx().sess.span_err(iterator_expr.span,
- &format!("`for` loop expression has type `{}` which does \
+ span_err!(fcx.tcx().sess, iterator_expr.span, E0234,
+ "`for` loop expression has type `{}` which does \
not implement the `Iterator` trait; \
- maybe try .iter()",
- ty_string)[]);
+ maybe try .iter()", ty_string);
}
fcx.tcx().types.err
}
fcx.tcx().types.err
}
_ => {
- fcx.tcx().sess.span_err(iterator_expr.span,
- &format!("`next` method of the `Iterator` \
+ span_err!(fcx.tcx().sess, iterator_expr.span, E0239,
+ "`next` method of the `Iterator` \
trait has an unexpected type `{}`",
- fcx.infcx().ty_to_string(return_type))
- []);
+ fcx.infcx().ty_to_string(return_type));
fcx.tcx().types.err
}
}
enum_id_opt: Option<ast::DefId>) {
let tcx = fcx.ccx.tcx;
- let mut class_field_map = FnvHashMap::new();
+ let mut class_field_map = FnvHashMap();
let mut fields_found = 0;
for field in field_types.iter() {
class_field_map.insert(field.name, (field.id, false));
Err(type_error) => {
let type_error_description =
ty::type_err_to_str(tcx, &type_error);
- fcx.tcx()
- .sess
- .span_err(path.span,
- &format!("structure constructor specifies a \
+ span_err!(fcx.tcx().sess, path.span, E0235,
+ "structure constructor specifies a \
structure of type `{}`, but this \
structure has type `{}`: {}",
fcx.infcx()
fcx.infcx()
.ty_to_string(
actual_structure_type),
- type_error_description)[]);
+ type_error_description);
ty::note_and_explain_type_err(tcx, &type_error);
}
}
ty::mk_struct(tcx, did, tcx.mk_substs(substs))
} else {
- tcx.sess.span_err(expr.span, "No lang item for range syntax");
+ span_err!(tcx.sess, expr.span, E0236, "no lang item for range syntax");
fcx.tcx().types.err
}
}
let substs = Substs::new_type(vec![], vec![]);
ty::mk_struct(tcx, did, tcx.mk_substs(substs))
} else {
- tcx.sess.span_err(expr.span, "No lang item for range syntax");
+ span_err!(tcx.sess, expr.span, E0237, "no lang item for range syntax");
fcx.tcx().types.err
}
}
}
ast::ParenthesizedParameters(ref data) => {
- fcx.tcx().sess.span_err(
- span,
+ span_err!(fcx.tcx().sess, span, E0238,
"parenthesized parameters may only be used with a trait");
push_explicit_parenthesized_parameters_from_segment_to_substs(
fcx, space, span, type_defs, data, substs);
"get_tydesc" => {
let tydesc_ty = match ty::get_tydesc_ty(ccx.tcx) {
Ok(t) => t,
- Err(s) => { tcx.sess.span_fatal(it.span, &s[]); }
+ Err(s) => { span_fatal!(tcx.sess, it.span, E0240, "{}", &s[]); }
};
let td_ptr = ty::mk_ptr(ccx.tcx, ty::mt {
ty: tydesc_ty,
});
(1u, Vec::new(), td_ptr)
}
- "type_id" => {
- let langid = ccx.tcx.lang_items.require(TypeIdLangItem);
- match langid {
- Ok(did) => (1u,
- Vec::new(),
- ty::mk_struct(ccx.tcx, did,
- ccx.tcx.mk_substs(subst::Substs::empty()))),
- Err(msg) => {
- tcx.sess.span_fatal(it.span, &msg[]);
- }
- }
- },
+ "type_id" => (1u, Vec::new(), ccx.tcx.types.u64),
"offset" => {
(1,
vec!(