.filter(|item| item.kind == ty::AssocKind::Fn)
.filter_map(|item| {
object_safety_violation_for_method(tcx, trait_def_id, &item)
- .map(|(code, span)| ObjectSafetyViolation::Method(item.ident.name, code, span))
+ .map(|(code, span)| ObjectSafetyViolation::Method(item.name, code, span))
})
.filter(|violation| {
if let ObjectSafetyViolation::Method(
tcx.associated_items(trait_def_id)
.in_definition_order()
.filter(|item| item.kind == ty::AssocKind::Const)
- .map(|item| ObjectSafetyViolation::AssocConst(item.ident.name, item.ident.span)),
+ .map(|item| {
+ let ident = item.ident(tcx);
+ ObjectSafetyViolation::AssocConst(ident.name, ident.span)
+ }),
);
violations.extend(
.in_definition_order()
.filter(|item| item.kind == ty::AssocKind::Type)
.filter(|item| !tcx.generics_of(item.def_id).params.is_empty())
- .map(|item| ObjectSafetyViolation::GAT(item.ident.name, item.ident.span)),
+ .map(|item| {
+ let ident = item.ident(tcx);
+ ObjectSafetyViolation::GAT(ident.name, ident.span)
+ }),
);
debug!(
(MethodViolationCode::ReferencesSelfInput(arg), Some(node)) => node
.fn_decl()
.and_then(|decl| decl.inputs.get(arg + 1))
- .map_or(method.ident.span, |arg| arg.span),
+ .map_or(method.ident(tcx).span, |arg| arg.span),
(MethodViolationCode::UndispatchableReceiver, Some(node)) => node
.fn_decl()
.and_then(|decl| decl.inputs.get(0))
- .map_or(method.ident.span, |arg| arg.span),
+ .map_or(method.ident(tcx).span, |arg| arg.span),
(MethodViolationCode::ReferencesSelfOutput, Some(node)) => {
- node.fn_decl().map_or(method.ident.span, |decl| decl.output.span())
+ node.fn_decl().map_or(method.ident(tcx).span, |decl| decl.output.span())
}
- _ => method.ident.span,
+ _ => method.ident(tcx).span,
};
(v, span)
})
);
// Get the span pointing at where the `self` receiver should be.
let sm = tcx.sess.source_map();
- let self_span = method.ident.span.to(tcx
+ let self_span = method.ident(tcx).span.to(tcx
.hir()
.span_if_local(method.def_id)
- .unwrap_or_else(|| sm.next_point(method.ident.span))
+ .unwrap_or_else(|| sm.next_point(method.ident(tcx).span))
.shrink_to_hi());
let self_span = sm.span_through_char(self_span, '(').shrink_to_hi();
return Some(MethodViolationCode::StaticMethod(
// `trait MyTrait: for<'s> OtherTrait<&'s T, Output=bool>`.
super_trait_ref.map_bound(|super_trait_ref| {
ty::ExistentialPredicate::Projection(ty::ExistentialProjection {
- ty: tcx.mk_projection(item.def_id, super_trait_ref.substs),
+ term: tcx.mk_projection(item.def_id, super_trait_ref.substs).into(),
item_def_id: item.def_id,
substs: super_trait_ref.substs,
})
}
}
- fn visit_const(&mut self, ct: &'tcx ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
- self.visit_ty(ct.ty)?;
-
+ fn visit_unevaluated_const(
+ &mut self,
+ uv: ty::Unevaluated<'tcx>,
+ ) -> ControlFlow<Self::BreakTy> {
// Constants can only influence object safety if they reference `Self`.
// This is only possible for unevaluated constants, so we walk these here.
//
// This shouldn't really matter though as we can't really use any
// constants which are not considered const evaluatable.
use rustc_middle::thir::abstract_const::Node;
- if let Ok(Some(ct)) = AbstractConst::from_const(self.tcx, ct) {
+ if let Ok(Some(ct)) = AbstractConst::new(self.tcx, uv.shrink()) {
const_evaluatable::walk_abstract_const(self.tcx, ct, |node| {
match node.root(self.tcx) {
Node::Leaf(leaf) => self.visit_const(leaf),
ControlFlow::CONTINUE
}
}
-
- fn visit_predicate(&mut self, pred: ty::Predicate<'tcx>) -> ControlFlow<Self::BreakTy> {
- if let ty::PredicateKind::ConstEvaluatable(uv) = pred.kind().skip_binder() {
- // FIXME(generic_const_exprs): We should probably deduplicate the logic for
- // `AbstractConst`s here, it might make sense to change `ConstEvaluatable` to
- // take a `ty::Const` instead.
- use rustc_middle::thir::abstract_const::Node;
- if let Ok(Some(ct)) = AbstractConst::new(self.tcx, uv) {
- const_evaluatable::walk_abstract_const(self.tcx, ct, |node| {
- match node.root(self.tcx) {
- Node::Leaf(leaf) => self.visit_const(leaf),
- Node::Cast(_, _, ty) => self.visit_ty(ty),
- Node::Binop(..) | Node::UnaryOp(..) | Node::FunctionCall(_, _) => {
- ControlFlow::CONTINUE
- }
- }
- })
- } else {
- ControlFlow::CONTINUE
- }
- } else {
- pred.super_visit_with(self)
- }
- }
}
value