-> Ty<'tcx>
{
if ty::binds_late_bound_regions(self.tcx(), &poly_trait_ref) {
- self.tcx().sess.span_err(
- span,
+ span_err!(self.tcx().sess, span, E0212,
"cannot extract an associated type from a higher-ranked trait bound \
in this context");
self.tcx().types.err
_item_name: ast::Name)
-> Ty<'tcx>
{
- self.tcx().sess.span_err(
- span,
+ span_err!(self.tcx().sess, span, E0213,
"associated types are not accepted in this context");
self.tcx().types.err
convert_angle_bracketed_parameters(this, rscope, data)
}
ast::ParenthesizedParameters(ref data) => {
- tcx.sess.span_err(
- path.span,
+ span_err!(tcx.sess, path.span, E0214,
"parenthesized parameters may only be used with a trait");
(Vec::new(), convert_parenthesized_parameters(this, data), Vec::new())
}
if !this.tcx().sess.features.borrow().unboxed_closures &&
this.tcx().lang_items.fn_trait_kind(trait_def_id).is_some()
{
- this.tcx().sess.span_err(path.span,
+ span_err!(this.tcx().sess, path.span, E0215,
"angle-bracket notation is not stable when \
used with the `Fn` family of traits, use parentheses");
span_help!(this.tcx().sess, path.span,
if !this.tcx().sess.features.borrow().unboxed_closures &&
this.tcx().lang_items.fn_trait_kind(trait_def_id).is_none()
{
- this.tcx().sess.span_err(path.span,
+ span_err!(this.tcx().sess, path.span, E0216,
"parenthetical notation is only stable when \
used with the `Fn` family of traits");
span_help!(this.tcx().sess, path.span,
}
if candidates.len() > 1 {
- tcx.sess.span_err(
- binding.span,
- format!("ambiguous associated type: `{}` defined in multiple supertraits `{}`",
+ span_err!(tcx.sess, binding.span, E0217,
+ "ambiguous associated type: `{}` defined in multiple supertraits `{}`",
token::get_name(binding.item_name),
- candidates.user_string(tcx)).as_slice());
+ candidates.user_string(tcx));
return Err(ErrorReported);
}
let candidate = match candidates.pop() {
Some(c) => c,
None => {
- tcx.sess.span_err(
- binding.span,
- format!("no associated type `{}` defined in `{}`",
+ span_err!(tcx.sess, binding.span, E0218,
+ "no associated type `{}` defined in `{}`",
token::get_name(binding.item_name),
- trait_ref.user_string(tcx)).as_slice());
+ trait_ref.user_string(tcx));
return Err(ErrorReported);
}
};
if ty::binds_late_bound_regions(tcx, &candidate) {
- tcx.sess.span_err(
- binding.span,
- format!("associated type `{}` defined in higher-ranked supertrait `{}`",
+ span_err!(tcx.sess, binding.span, E0219,
+ "associated type `{}` defined in higher-ranked supertrait `{}`",
token::get_name(binding.item_name),
- candidate.user_string(tcx)).as_slice());
+ candidate.user_string(tcx));
return Err(ErrorReported);
}
}
if suitable_bounds.len() == 0 {
- tcx.sess.span_err(ast_ty.span,
- format!("associated type `{}` not found for type parameter `{}`",
+ span_err!(tcx.sess, ast_ty.span, E0220,
+ "associated type `{}` not found for type parameter `{}`",
token::get_name(assoc_name),
- token::get_name(ty_param_name)).as_slice());
+ token::get_name(ty_param_name));
return this.tcx().types.err;
}
if suitable_bounds.len() > 1 {
- tcx.sess.span_err(ast_ty.span,
- format!("ambiguous associated type `{}` in bounds of `{}`",
+ span_err!(tcx.sess, ast_ty.span, E0221,
+ "ambiguous associated type `{}` in bounds of `{}`",
token::get_name(assoc_name),
- token::get_name(ty_param_name)).as_slice());
+ token::get_name(ty_param_name));
for suitable_bound in suitable_bounds.iter() {
span_note!(this.tcx().sess, ast_ty.span,
ast::TyParen(ref typ) => ast_ty_to_ty(this, rscope, &**typ),
ast::TyBareFn(ref bf) => {
if bf.decl.variadic && bf.abi != abi::C {
- tcx.sess.span_err(ast_ty.span,
+ span_err!(tcx.sess, ast_ty.span, E0222,
"variadic function must have C calling convention");
}
let bare_fn = ty_of_bare_fn(this, bf.unsafety, bf.abi, &*bf.decl);
def::DefAssociatedTy(trait_type_id) => {
let path_str = tcx.map.path_to_string(
tcx.map.get_parent(trait_type_id.node));
- tcx.sess.span_err(ast_ty.span,
- &format!("ambiguous associated \
+ span_err!(tcx.sess, ast_ty.span, E0223,
+ "ambiguous associated \
type; specify the type \
using the syntax `<Type \
as {}>::{}`",
.last()
.unwrap()
.identifier)
- .get())[]);
+ .get());
this.tcx().types.err
}
def::DefAssociatedPath(provenance, assoc_ident) => {
None,
&mut projection_bounds))
} else {
- this.tcx().sess.span_err(
- span,
+ span_err!(this.tcx().sess, span, E0224,
"at least one non-builtin trait is required for an object type");
None
};
if !trait_bounds.is_empty() {
let b = &trait_bounds[0];
- this.tcx().sess.span_err(
- b.trait_ref.path.span,
- &format!("only the builtin traits can be used \
- as closure or object bounds")[]);
+ span_err!(this.tcx().sess, b.trait_ref.path.span, E0225,
+ "only the builtin traits can be used \
+ as closure or object bounds");
}
let region_bound = compute_region_bound(this,
builtin_bounds.repr(tcx));
if explicit_region_bounds.len() > 1 {
- tcx.sess.span_err(
- explicit_region_bounds[1].span,
- format!("only a single explicit lifetime bound is permitted").as_slice());
+ span_err!(tcx.sess, explicit_region_bounds[1].span, E0226,
+ "only a single explicit lifetime bound is permitted");
}
if explicit_region_bounds.len() != 0 {
// error.
let r = derived_region_bounds[0];
if derived_region_bounds.slice_from(1).iter().any(|r1| r != *r1) {
- tcx.sess.span_err(
- span,
- &format!("ambiguous lifetime bound, \
- explicit lifetime bound required")[]);
+ span_err!(tcx.sess, span, E0227,
+ "ambiguous lifetime bound, \
+ explicit lifetime bound required");
}
return Some(r);
}
match rscope.default_region_bound(span) {
Some(r) => { r }
None => {
- this.tcx().sess.span_err(
- span,
- &format!("explicit lifetime bound required")[]);
+ span_err!(this.tcx().sess, span, E0228,
+ "explicit lifetime bound required");
ty::ReStatic
}
}
bindings: &[ConvertedBinding<'tcx>])
{
for binding in bindings.iter().take(1) {
- tcx.sess.span_err(
- binding.span,
+ span_err!(tcx.sess, binding.span, E0229,
"associated type bindings are not allowed here");
}
}
check_unboxed_closure(fcx, expr, kind, decl, body, None);
- fcx.ccx.tcx.sess.span_err(
- expr.span,
+ span_err!(fcx.ccx.tcx.sess, expr.span, E0187,
"can't infer the \"kind\" of the closure, explicitly annotate it. e.g. \
- `|&:| {}`");
+ `|&:| {{}}`");
},
Some((sig, kind)) => {
check_unboxed_closure(fcx, expr, kind, decl, body, Some(sig));
(&ty::StaticExplicitSelfCategory,
&ty::StaticExplicitSelfCategory) => {}
(&ty::StaticExplicitSelfCategory, _) => {
- tcx.sess.span_err(
- impl_m_span,
- format!("method `{}` has a `{}` declaration in the impl, \
+ span_err!(tcx.sess, impl_m_span, E0185,
+ "method `{}` has a `{}` declaration in the impl, \
but not in the trait",
token::get_name(trait_m.name),
ppaux::explicit_self_category_to_str(
- &impl_m.explicit_self)).as_slice());
+ &impl_m.explicit_self));
return;
}
(_, &ty::StaticExplicitSelfCategory) => {
- tcx.sess.span_err(
- impl_m_span,
- format!("method `{}` has a `{}` declaration in the trait, \
+ span_err!(tcx.sess, impl_m_span, E0186,
+ "method `{}` has a `{}` declaration in the trait, \
but not in the impl",
token::get_name(trait_m.name),
ppaux::explicit_self_category_to_str(
- &trait_m.explicit_self)).as_slice());
+ &trait_m.explicit_self));
return;
}
_ => {
// are zero. Since I don't quite know how to phrase things at
// the moment, give a kind of vague error message.
if trait_params.len() != impl_params.len() {
- tcx.sess.span_err(
- span,
- &format!("lifetime parameters or bounds on method `{}` do \
+ span_err!(tcx.sess, span, E0195,
+ "lifetime parameters or bounds on method `{}` do \
not match the trait declaration",
- token::get_name(impl_m.name))[]);
+ token::get_name(impl_m.name));
return false;
}
}) {
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\"]`")
}
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
}
}
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);
{
let object_trait = object_trait(&object_trait_ty);
if !mutability_allowed(referent_mutbl, target_mutbl) {
- fcx.tcx().sess.span_err(source_expr.span,
+ span_err!(fcx.tcx().sess, source_expr.span, E0188,
"types differ in mutability");
} else {
// Ensure that if &'a T is cast to &'b Trait, then T : Trait
}
(_, &ty::ty_uniq(..)) => {
- fcx.ccx.tcx.sess.span_err(
- source_expr.span,
- &format!("can only cast an boxed pointer \
+ span_err!(fcx.ccx.tcx.sess, source_expr.span, E0189,
+ "can only cast a boxed pointer \
to a boxed object, not a {}",
- ty::ty_sort_string(fcx.tcx(), source_ty))[]);
+ ty::ty_sort_string(fcx.tcx(), source_ty));
}
(_, &ty::ty_rptr(..)) => {
- fcx.ccx.tcx.sess.span_err(
- source_expr.span,
- &format!("can only cast a &-pointer \
+ span_err!(fcx.ccx.tcx.sess, source_expr.span, E0190,
+ "can only cast a &-pointer \
to an &-object, not a {}",
- ty::ty_sort_string(fcx.tcx(), source_ty))[]);
+ ty::ty_sort_string(fcx.tcx(), source_ty));
}
_ => {
}
for (trait_def_id, name) in associated_types.into_iter() {
- tcx.sess.span_err(
- span,
- format!("the value of the associated type `{}` (from the trait `{}`) must be specified",
+ span_err!(tcx.sess, span, E0191,
+ "the value of the associated type `{}` (from the trait `{}`) must be specified",
name.user_string(tcx),
- ty::item_path_str(tcx, trait_def_id)).as_slice());
+ ty::item_path_str(tcx, trait_def_id));
}
}
match ccx.tcx.lang_items.to_builtin_kind(trait_ref.def_id) {
Some(ty::BoundSend) | Some(ty::BoundSync) => {}
Some(_) | None => {
- ccx.tcx.sess.span_err(
- item.span,
- format!("negative impls are currently \
- allowed just for `Send` and `Sync`").as_slice())
+ span_err!(ccx.tcx.sess, item.span, E0192,
+ "negative impls are currently \
+ allowed just for `Send` and `Sync`")
}
}
}
fn report_bound_error<'t>(tcx: &ty::ctxt<'t>,
span: Span,
bounded_ty: ty::Ty<'t>) {
- tcx.sess.span_err(
- span,
- format!("cannot bound type `{}`, where clause \
+ span_err!(tcx.sess, span, E0193,
+ "cannot bound type `{}`, where clause \
bounds may only be attached to types involving \
type parameters",
- bounded_ty.repr(tcx)).as_slice())
+ bounded_ty.repr(tcx))
}
fn is_ty_param(ty: ty::Ty) -> bool {
for method_param in generics.types.get_slice(subst::FnSpace).iter() {
if impl_params.contains(&method_param.name) {
- tcx.sess.span_err(
- span,
- &*format!("type parameter `{}` shadows another type parameter of the same name",
- token::get_name(method_param.name)));
+ span_err!(tcx.sess, span, E0194,
+ "type parameter `{}` shadows another type parameter of the same name",
+ token::get_name(method_param.name));
}
}
}
ResolvingUnboxedClosure(_) => {
let span = self.reason.span(self.tcx);
- self.tcx.sess.span_err(span,
+ span_err!(self.tcx.sess, span, E0196,
"cannot determine a type for this \
unboxed closure")
}
match trait_ref.self_ty().sty {
ty::ty_struct(..) | ty::ty_enum(..) => {}
_ => {
- self.tcx.sess.span_err(
- item.span,
- &format!("builtin traits can only be \
- implemented on structs or enums")[]);
+ span_err!(self.tcx.sess, item.span, E0209,
+ "builtin traits can only be \
+ implemented on structs or enums");
}
}
}
match ty::can_type_implement_copy(¶m_env, span, self_type) {
Ok(()) => {}
Err(ty::FieldDoesNotImplementCopy(name)) => {
- tcx.sess
- .span_err(span,
- &format!("the trait `Copy` may not be \
+ span_err!(tcx.sess, span, E0204,
+ "the trait `Copy` may not be \
implemented for this type; field \
`{}` does not implement `Copy`",
- token::get_name(name))[])
+ token::get_name(name))
}
Err(ty::VariantDoesNotImplementCopy(name)) => {
- tcx.sess
- .span_err(span,
- &format!("the trait `Copy` may not be \
+ span_err!(tcx.sess, span, E0205,
+ "the trait `Copy` may not be \
implemented for this type; variant \
`{}` does not implement `Copy`",
- token::get_name(name))[])
+ token::get_name(name))
}
Err(ty::TypeIsStructural) => {
- tcx.sess
- .span_err(span,
+ span_err!(tcx.sess, span, E0206,
"the trait `Copy` may not be implemented \
for this type; type is not a structure or \
enumeration")
}
Err(traits::OrphanCheckErr::UncoveredTy(param_ty)) => {
if !ty::has_attr(self.tcx, trait_def_id, "old_orphan_check") {
- self.tcx.sess.span_err(
- item.span,
- format!(
+ span_err!(self.tcx.sess, item.span, E0210,
"type parameter `{}` is not constrained by any local type; \
only traits defined in the current crate can be implemented \
for a type parameter",
- param_ty.user_string(self.tcx)).as_slice());
+ param_ty.user_string(self.tcx));
self.tcx.sess.span_note(
item.span,
format!("for a limited time, you can add \
match unsafety {
ast::Unsafety::Normal => { /* OK */ }
ast::Unsafety::Unsafe => {
- self.tcx.sess.span_err(
- item.span,
+ span_err!(self.tcx.sess, item.span, E0197,
"inherent impls cannot be declared as unsafe");
}
}
match (trait_def.unsafety, unsafety, polarity) {
(ast::Unsafety::Unsafe,
ast::Unsafety::Unsafe, ast::ImplPolarity::Negative) => {
- self.tcx.sess.span_err(
- item.span,
- format!("negative implementations are not unsafe").as_slice());
+ span_err!(self.tcx.sess, item.span, E0198,
+ "negative implementations are not unsafe");
}
(ast::Unsafety::Normal, ast::Unsafety::Unsafe, _) => {
- self.tcx.sess.span_err(
- item.span,
- format!("implementing the trait `{}` is not unsafe",
- trait_ref.user_string(self.tcx)).as_slice());
+ span_err!(self.tcx.sess, item.span, E0199,
+ "implementing the trait `{}` is not unsafe",
+ trait_ref.user_string(self.tcx));
}
(ast::Unsafety::Unsafe,
ast::Unsafety::Normal, ast::ImplPolarity::Positive) => {
- self.tcx.sess.span_err(
- item.span,
- format!("the trait `{}` requires an `unsafe impl` declaration",
- trait_ref.user_string(self.tcx)).as_slice());
+ span_err!(self.tcx.sess, item.span, E0200,
+ "the trait `{}` requires an `unsafe impl` declaration",
+ trait_ref.user_string(self.tcx));
}
(ast::Unsafety::Unsafe,
let mut seen_methods = FnvHashSet();
for m in ms {
if !seen_methods.insert(m.pe_ident().repr(tcx)) {
- tcx.sess.span_err(m.span, "duplicate method in trait impl");
+ span_err!(tcx.sess, m.span, E0201, "duplicate method in trait impl");
}
let m_def_id = local_def(m.id);
}
ast::TypeImplItem(ref typedef) => {
if opt_trait_ref.is_none() {
- tcx.sess.span_err(typedef.span,
+ span_err!(tcx.sess, typedef.span, E0202,
"associated items are not allowed in inherent impls");
}
assert!(ptr.bound_lifetimes.is_empty());
unbound = Some(ptr.trait_ref.clone());
} else {
- ccx.tcx.sess.span_err(span, "type parameter has more than one relaxed default \
+ span_err!(ccx.tcx.sess, span, E0203,
+ "type parameter has more than one relaxed default \
bound, only one is supported");
}
}
impl trait, self type, or predicates",
param_ty.user_string(tcx)).as_slice());
} else {
- tcx.sess.span_err(
- ty_param.span,
- format!("the type parameter `{}` is not constrained by the \
+ span_err!(tcx.sess, ty_param.span, E0207,
+ "the type parameter `{}` is not constrained by the \
impl trait, self type, or predicates",
- param_ty.user_string(tcx)).as_slice());
+ param_ty.user_string(tcx));
tcx.sess.span_help(
ty_param.span,
format!("you can temporarily opt out of this rule by placing \
E0178,
E0182,
E0183,
- E0184
+ E0184,
+ E0185,
+ E0186,
+ E0187, // can't infer the kind of the closure
+ E0188, // types differ in mutability
+ E0189, // can only cast a boxed pointer to a boxed object
+ E0190, // can only cast a &-pointer to an &-object
+ E0191, // value of the associated type must be specified
+ E0192, // negative imples are allowed just fo `Send` and `Sync`
+ E0193, // cannot bound type where clause bounds may only be attached to types
+ // involving type parameters
+ E0194,
+ E0195, // lifetime parameters or bounds on method do not match the trait declaration
+ E0196, // cannot determine a type for this unboxed closure
+ E0197, // inherent impls cannot be declared as unsafe
+ E0198, // negative implementations are not unsafe
+ E0199, // implementing trait is not unsafe
+ E0200, // trait requires an `unsafe impl` declaration
+ E0201, // duplicate method in trait impl
+ E0202, // associated items are not allowed in inherint impls
+ E0203, // type parameter has more than one relaxed default bound,
+ // and only one is supported
+ E0204, // trait `Copy` may not be implemented for this type; field
+ // does not implement `Copy`
+ E0205, // trait `Copy` may not be implemented for this type; variant
+ // does not implement `copy`
+ E0206, // trait `Copy` may not be implemented for this type; type is
+ // not a structure or enumeration
+ E0207, // type parameter is not constrained by the impl trait, self type, or predicate
+ E0208,
+ E0209, // builtin traits can only be implemented on structs or enums
+ E0210, // type parameter is not constrained by any local type
+ E0211,
+ E0212, // cannot extract an associated type from a higher-ranked trait bound
+ E0213, // associated types are not accepted in this context
+ E0214, // parenthesized parameters may only be used with a trait
+ E0215, // angle-bracket notation is not stable with `Fn`
+ E0216, // parenthetical notation is only stable with `Fn`
+ E0217, // ambiguous associated type, defined in multiple supertraits
+ E0218, // no associated type defined
+ E0219, // associated type defined in higher-ranked supertrait
+ E0220, // associated type not found for type parameter
+ E0221, // ambiguous associated type in bounds
+ E0222, // variadic function must have C calling convention
+ E0223, // ambiguous associated type
+ E0224, // at least one non-builtin train is required for an object type
+ E0225, // only the builtin traits can be used as closure or object bounds
+ E0226, // only a single explicit lifetime bound is permitted
+ E0227, // ambiguous lifetime bound, explicit lifetime bound required
+ E0228, // explicit lifetime bound required
+ E0229, // associated type bindings are not allowed here
+ E0230, // there is no type parameter on trait
+ E0231, // only named substitution parameters are allowed
+ E0232, // this attribute must have a value
+ E0233,
+ E0234, // `for` loop expression has type which does not implement the `Iterator` trait
+ E0235, // structure constructor specifies a structure of type but
+ E0236, // no lang item for range syntax
+ E0237, // no lang item for range syntax
+ E0238, // parenthesized parameters may only be used with a trait
+ E0239 // `next` method of `Iterator` trait has unexpected type
}
__build_diagnostic_array! { DIAGNOSTICS }
match result {
Ok(_) => true,
Err(ref terr) => {
- tcx.sess.span_err(span,
- &format!("{}: {}",
+ span_err!(tcx.sess, span, E0211,
+ "{}: {}",
msg(),
ty::type_err_to_str(tcx,
- terr))[]);
+ terr));
ty::note_and_explain_type_err(tcx, terr);
false
}
// attribute and report an error with various results if found.
if ty::has_attr(tcx, item_def_id, "rustc_variance") {
let found = item_variances.repr(tcx);
- tcx.sess.span_err(tcx.map.span(item_id), &found[]);
+ span_err!(tcx.sess, tcx.map.span(item_id), E0208, "{}", &found[]);
}
let newly_added = tcx.item_variance_map.borrow_mut()