bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Remove HirVec from Generics.

Browse source
This commit is contained in:
Camille GILLOT 2019-12-01 17:10:12 +01:00
parent d297b19663
commit aa3678d4f4
14 changed files with 127 additions and 87 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/librustc/hir/intravisit.rs
View file

@ -672,7 +672,7 @@ pub fn walk_generic_args<'v, V: Visitor<'v>>(
_path_span: Span,
generic_args: &'v GenericArgs<'v>,
) {
walk_list!(visitor, visit_generic_arg, &generic_args.args);
walk_list!(visitor, visit_generic_arg, generic_args.args);
walk_list!(visitor, visit_assoc_type_binding, generic_args.bindings);
}
@ -780,7 +780,7 @@ pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v Generi
}
pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics<'v>) {
walk_list!(visitor, visit_generic_param, &generics.params);
walk_list!(visitor, visit_generic_param, generics.params);
walk_list!(visitor, visit_where_predicate, generics.where_clause.predicates);
}

97
src/librustc/hir/lowering.rs
View file

@ -893,7 +893,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// in-band-lifetimes introduced by generics or where-clauses
// wouldn't have been added yet.
let generics =
this.lower_generics(generics, ImplTraitContext::Universal(&mut params));
this.lower_generics_mut(generics, ImplTraitContext::Universal(&mut params));
let res = f(this, &mut params);
(params, (generics, res))
})
@ -914,6 +914,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
lowered_generics.params = lowered_params.into();
let lowered_generics = lowered_generics.into_generics(self.arena);
(lowered_generics, res)
}
@ -1224,17 +1225,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
};
hir::TyKind::Rptr(lifetime, self.lower_mt(mt, itctx))
}
TyKind::BareFn(ref f) => self.with_in_scope_lifetime_defs(&f.generic_params, |this| {
this.with_anonymous_lifetime_mode(AnonymousLifetimeMode::PassThrough, |this| {
hir::TyKind::BareFn(
this.arena.alloc(hir::BareFnTy {
generic_params: this.arena.alloc_from_iter(
this.lower_generic_params(
&f.generic_params,
&NodeMap::default(),
ImplTraitContext::disallowed(),
)
.into_iter(),
TyKind::BareFn(ref f) => {
self.with_in_scope_lifetime_defs(&f.generic_params, |this| {
this.with_anonymous_lifetime_mode(AnonymousLifetimeMode::PassThrough, |this| {
hir::TyKind::BareFn(this.arena.alloc(hir::BareFnTy {
generic_params: this.lower_generic_params(
&f.generic_params,
&NodeMap::default(),
ImplTraitContext::disallowed(),
),
unsafety: f.unsafety,
abi: this.lower_extern(f.ext),
@ -1242,10 +1240,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
param_names: this.arena.alloc_from_iter(
this.lower_fn_params_to_names(&f.decl).into_iter(),
),
}),
)
}))
})
})
}),
}
TyKind::Never => hir::TyKind::Never,
TyKind::Tup(ref tys) => {
hir::TyKind::Tup(self.arena.alloc_from_iter(
@ -1414,12 +1412,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
opaque_ty_def_index,
&hir_bounds,
);
let lifetime_defs = self.arena.alloc_from_iter(lifetime_defs.into_iter());
debug!("lower_opaque_impl_trait: lifetimes={:#?}", lifetimes,);
debug!("lower_opaque_impl_trait: lifetime_defs={:#?}", lifetime_defs,);
self.with_hir_id_owner(opaque_ty_node_id, |lctx| {
self.with_hir_id_owner(opaque_ty_node_id, move |lctx| {
let opaque_ty_item = hir::OpaqueTy {
generics: hir::Generics {
params: lifetime_defs,
@ -1978,7 +1977,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
hir_id: Some(id),
res: Some(self.lower_res(res)),
infer_args,
args: if generic_args.is_empty() { None } else { Some(self.arena.alloc(generic_args)) },
args: if generic_args.is_empty() {
None
} else {
Some(self.arena.alloc(generic_args.into_generic_args(self.arena)))
},
}
}
@ -1987,7 +1990,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
data: &AngleBracketedArgs,
param_mode: ParamMode,
mut itctx: ImplTraitContext<'_, 'hir>,
) -> (hir::GenericArgs<'hir>, bool) {
) -> (GenericArgsCtor<'hir>, bool) {
let &AngleBracketedArgs { ref args, ref constraints, .. } = data;
let has_non_lt_args = args.iter().any(|arg| match arg {
ast::GenericArg::Lifetime(_) => false,
@ -1995,7 +1998,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
ast::GenericArg::Const(_) => true,
});
(
hir::GenericArgs {
GenericArgsCtor {
args: args.iter().map(|a| self.lower_generic_arg(a, itctx.reborrow())).collect(),
bindings: self.arena.alloc_from_iter(
constraints.iter().map(|b| self.lower_assoc_ty_constraint(b, itctx.reborrow())),
@ -2009,7 +2012,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn lower_parenthesized_parameter_data(
&mut self,
data: &ParenthesizedArgs,
) -> (hir::GenericArgs<'hir>, bool) {
) -> (GenericArgsCtor<'hir>, bool) {
// Switch to `PassThrough` mode for anonymous lifetimes; this
// means that we permit things like `&Ref<T>`, where `Ref` has
// a hidden lifetime parameter. This is needed for backwards
@ -2024,7 +2027,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
FunctionRetTy::Ty(ty) => this.lower_ty(&ty, ImplTraitContext::disallowed()),
FunctionRetTy::Default(_) => this.arena.alloc(this.ty_tup(span, &[])),
};
let args = hir_vec![GenericArg::Type(this.ty_tup(span, inputs))];
let args = vec![GenericArg::Type(this.ty_tup(span, inputs))];
let binding = hir::TypeBinding {
hir_id: this.next_id(),
ident: Ident::with_dummy_span(FN_OUTPUT_NAME),
@ -2032,7 +2035,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
kind: hir::TypeBindingKind::Equality { ty: output_ty },
};
(
hir::GenericArgs { args, bindings: arena_vec![this; binding], parenthesized: true },
GenericArgsCtor { args, bindings: arena_vec![this; binding], parenthesized: true },
false,
)
})
@ -2310,12 +2313,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
debug!("lower_async_fn_ret_ty: lifetimes_to_define={:#?}", this.lifetimes_to_define);
debug!("lower_async_fn_ret_ty: lifetime_params={:#?}", lifetime_params);
let generic_params = lifetime_params
.iter()
.map(|(span, hir_name)| {
let generic_params =
this.arena.alloc_from_iter(lifetime_params.iter().map(|(span, hir_name)| {
this.lifetime_to_generic_param(*span, *hir_name, opaque_ty_def_index)
})
.collect();
}));
let opaque_ty_item = hir::OpaqueTy {
generics: hir::Generics {
@ -2395,7 +2396,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// "<Output = T>"
let future_params = self.arena.alloc(hir::GenericArgs {
args: HirVec::new(),
args: &[],
bindings: arena_vec![self; hir::TypeBinding {
ident: Ident::with_dummy_span(FN_OUTPUT_NAME),
kind: hir::TypeBindingKind::Equality { ty: output_ty },
@ -2474,18 +2475,27 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
hir::Lifetime { hir_id: self.lower_node_id(id), span, name }
}
fn lower_generic_params(
fn lower_generic_params_mut(
&mut self,
params: &[GenericParam],
add_bounds: &NodeMap<Vec<GenericBound>>,
mut itctx: ImplTraitContext<'_, 'hir>,
) -> HirVec<hir::GenericParam<'hir>> {
) -> Vec<hir::GenericParam<'hir>> {
params
.iter()
.map(|param| self.lower_generic_param(param, add_bounds, itctx.reborrow()))
.collect()
}
fn lower_generic_params(
&mut self,
params: &[GenericParam],
add_bounds: &NodeMap<Vec<GenericBound>>,
itctx: ImplTraitContext<'_, 'hir>,
) -> &'hir [hir::GenericParam<'hir>] {
self.arena.alloc_from_iter(self.lower_generic_params_mut(params, add_bounds, itctx))
}
fn lower_generic_param(
&mut self,
param: &GenericParam,
@ -2593,11 +2603,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
this.lower_trait_ref(&p.trait_ref, itctx)
});
hir::PolyTraitRef {
bound_generic_params: self.arena.alloc_from_iter(bound_generic_params.into_iter()),
trait_ref,
span: p.span,
}
hir::PolyTraitRef { bound_generic_params, trait_ref, span: p.span }
}
fn lower_mt(&mut self, mt: &MutTy, itctx: ImplTraitContext<'_, 'hir>) -> hir::MutTy<'hir> {
@ -3304,3 +3310,24 @@ fn body_ids(bodies: &BTreeMap<hir::BodyId, hir::Body<'hir>>) -> Vec<hir::BodyId>
body_ids.sort_by_key(|b| bodies[b].value.span);
body_ids
}
/// Helper struct for delayed construction of GenericArgs.
struct GenericArgsCtor<'hir> {
args: Vec<hir::GenericArg<'hir>>,
bindings: &'hir [hir::TypeBinding<'hir>],
parenthesized: bool,
}
impl GenericArgsCtor<'hir> {
fn is_empty(&self) -> bool {
self.args.is_empty() && self.bindings.is_empty() && !self.parenthesized
}
fn into_generic_args(self, arena: &'hir Arena<'hir>) -> hir::GenericArgs<'hir> {
hir::GenericArgs {
args: arena.alloc_from_iter(self.args),
bindings: self.bindings,
parenthesized: self.parenthesized,
}
}
}

46
src/librustc/hir/lowering/item.rs
View file

@ -5,6 +5,7 @@ use super::ImplTraitTypeIdVisitor;
use super::LoweringContext;
use super::ParamMode;
use crate::arena::Arena;
use crate::hir;
use crate::hir::def::{DefKind, Res};
use crate::hir::def_id::DefId;
@ -1295,11 +1296,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
}
pub(super) fn lower_generics(
pub(super) fn lower_generics_mut(
&mut self,
generics: &Generics,
itctx: ImplTraitContext<'_, 'hir>,
) -> hir::Generics<'hir> {
) -> GenericsCtor<'hir> {
// Collect `?Trait` bounds in where clause and move them to parameter definitions.
// FIXME: this could probably be done with less rightward drift. It also looks like two
// control paths where `report_error` is called are the only paths that advance to after the
@ -1355,13 +1356,22 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
}
hir::Generics {
params: self.lower_generic_params(&generics.params, &add_bounds, itctx),
GenericsCtor {
params: self.lower_generic_params_mut(&generics.params, &add_bounds, itctx),
where_clause: self.lower_where_clause(&generics.where_clause),
span: generics.span,
}
}
pub(super) fn lower_generics(
&mut self,
generics: &Generics,
itctx: ImplTraitContext<'_, 'hir>,
) -> hir::Generics<'hir> {
let generics_ctor = self.lower_generics_mut(generics, itctx);
generics_ctor.into_generics(self.arena)
}
fn lower_where_clause(&mut self, wc: &WhereClause) -> hir::WhereClause<'hir> {
self.with_anonymous_lifetime_mode(AnonymousLifetimeMode::ReportError, |this| {
hir::WhereClause {
@ -1383,13 +1393,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
}) => {
self.with_in_scope_lifetime_defs(&bound_generic_params, |this| {
hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate {
bound_generic_params: this.arena.alloc_from_iter(
this.lower_generic_params(
bound_generic_params,
&NodeMap::default(),
ImplTraitContext::disallowed(),
)
.into_iter(),
bound_generic_params: this.lower_generic_params(
bound_generic_params,
&NodeMap::default(),
ImplTraitContext::disallowed(),
),
bounded_ty: this.lower_ty(bounded_ty, ImplTraitContext::disallowed()),
bounds: this.arena.alloc_from_iter(bounds.iter().filter_map(|bound| {
@ -1426,3 +1433,20 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
}
}
/// Helper struct for delayed construction of Generics.
pub(super) struct GenericsCtor<'hir> {
pub(super) params: Vec<hir::GenericParam<'hir>>,
where_clause: hir::WhereClause<'hir>,
span: Span,
}
impl GenericsCtor<'hir> {
pub(super) fn into_generics(self, arena: &'hir Arena<'hir>) -> hir::Generics<'hir> {
hir::Generics {
params: arena.alloc_from_iter(self.params),
where_clause: self.where_clause,
span: self.span,
}
}
}

27
src/librustc/hir/mod.rs
View file

@ -41,15 +41,6 @@ use syntax_pos::{MultiSpan, Span, DUMMY_SP};
/// of `Vec` to avoid keeping extra capacity.
pub type HirVec<T> = P<[T]>;
macro_rules! hir_vec {
($elem:expr; $n:expr) => (
$crate::hir::HirVec::from(vec![$elem; $n])
);
($($x:expr),*) => (
$crate::hir::HirVec::from(vec![$($x),*])
);
}
pub mod check_attr;
pub mod def;
pub mod def_id;
@ -415,7 +406,7 @@ impl GenericArg<'_> {
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct GenericArgs<'hir> {
/// The generic arguments for this path segment.
pub args: HirVec<GenericArg<'hir>>,
pub args: &'hir [GenericArg<'hir>],
/// Bindings (equality constraints) on associated types, if present.
/// E.g., `Foo<A = Bar>`.
pub bindings: &'hir [TypeBinding<'hir>],
@ -427,7 +418,7 @@ pub struct GenericArgs<'hir> {
impl GenericArgs<'_> {
pub const fn none() -> Self {
Self { args: HirVec::new(), bindings: &[], parenthesized: false }
Self { args: &[], bindings: &[], parenthesized: false }
}
pub fn is_empty(&self) -> bool {
@ -436,7 +427,7 @@ impl GenericArgs<'_> {
pub fn inputs(&self) -> &[Ty<'_>] {
if self.parenthesized {
for arg in &self.args {
for arg in self.args {
match arg {
GenericArg::Lifetime(_) => {}
GenericArg::Type(ref ty) => {
@ -458,7 +449,7 @@ impl GenericArgs<'_> {
// presence of this method will be a constant reminder.
let mut own_counts: GenericParamCount = Default::default();
for arg in &self.args {
for arg in self.args {
match arg {
GenericArg::Lifetime(_) => own_counts.lifetimes += 1,
GenericArg::Type(_) => own_counts.types += 1,
@ -555,7 +546,7 @@ pub struct GenericParamCount {
/// of a function, enum, trait, etc.
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct Generics<'hir> {
pub params: HirVec<GenericParam<'hir>>,
pub params: &'hir [GenericParam<'hir>],
pub where_clause: WhereClause<'hir>,
pub span: Span,
}
@ -563,7 +554,7 @@ pub struct Generics<'hir> {
impl Generics<'hir> {
pub const fn empty() -> Generics<'hir> {
Generics {
params: HirVec::new(),
params: &[],
where_clause: WhereClause { predicates: &[], span: DUMMY_SP },
span: DUMMY_SP,
}
@ -575,7 +566,7 @@ impl Generics<'hir> {
// presence of this method will be a constant reminder.
let mut own_counts: GenericParamCount = Default::default();
for param in &self.params {
for param in self.params {
match param.kind {
GenericParamKind::Lifetime { .. } => own_counts.lifetimes += 1,
GenericParamKind::Type { .. } => own_counts.types += 1,
@ -587,7 +578,7 @@ impl Generics<'hir> {
}
pub fn get_named(&self, name: Symbol) -> Option<&GenericParam<'_>> {
for param in &self.params {
for param in self.params {
if name == param.name.ident().name {
return Some(param);
}
@ -2128,7 +2119,7 @@ pub struct InlineAsmOutput {
}
// NOTE(eddyb) This is used within MIR as well, so unlike the rest of the HIR,
// it needs to be `Clone` and use plain `Vec<T>` instead of `HirVec<T>`.
// it needs to be `Clone` and use plain `Vec<T>` instead of arena-allocated slice.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable, PartialEq)]
pub struct InlineAsmInner {
pub asm: Symbol,

3
src/librustc/hir/print.rs
View file

@ -10,7 +10,6 @@ use syntax::util::parser::{self, AssocOp, Fixity};
use syntax_pos::{self, BytePos, FileName};
use crate::hir;
use crate::hir::HirVec;
use crate::hir::{GenericArg, GenericParam, GenericParamKind};
use crate::hir::{GenericBound, PatKind, RangeEnd, TraitBoundModifier};
@ -2097,7 +2096,7 @@ impl<'a> State<'a> {
self.print_generic_params(generic_params);
}
let generics = hir::Generics {
params: HirVec::new(),
params: &[],
where_clause: hir::WhereClause { predicates: &[], span: syntax_pos::DUMMY_SP },
span: syntax_pos::DUMMY_SP,
};

10
src/librustc/middle/resolve_lifetime.rs
View file

@ -657,7 +657,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
let mut elision = None;
let mut lifetimes = FxHashMap::default();
let mut non_lifetime_count = 0;
for param in &generics.params {
for param in generics.params {
match param.kind {
GenericParamKind::Lifetime { .. } => {
let (name, reg) = Region::early(&self.tcx.hir(), &mut index, &param);
@ -899,7 +899,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) {
check_mixed_explicit_and_in_band_defs(self.tcx, &generics.params);
for param in &generics.params {
for param in generics.params {
match param.kind {
GenericParamKind::Lifetime { .. } => {}
GenericParamKind::Type { ref default, .. } => {
@ -1996,7 +1996,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
debug!("visit_segment_args: object_lifetime_defaults={:?}", object_lifetime_defaults);
let mut i = 0;
for arg in &generic_args.args {
for arg in generic_args.args {
match arg {
GenericArg::Lifetime(_) => {}
GenericArg::Type(ty) => {
@ -2789,7 +2789,7 @@ fn insert_late_bound_lifetimes(
let mut appears_in_where_clause = AllCollector::default();
appears_in_where_clause.visit_generics(generics);
for param in &generics.params {
for param in generics.params {
if let hir::GenericParamKind::Lifetime { .. } = param.kind {
if !param.bounds.is_empty() {
// `'a: 'b` means both `'a` and `'b` are referenced
@ -2809,7 +2809,7 @@ fn insert_late_bound_lifetimes(
// - appear in the inputs
// - do not appear in the where-clauses
// - are not implicitly captured by `impl Trait`
for param in &generics.params {
for param in generics.params {
match param.kind {
hir::GenericParamKind::Lifetime { .. } => { /* fall through */ }

4
src/librustc_lint/builtin.rs
View file

@ -841,7 +841,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidNoMangleItems {
match it.kind {
hir::ItemKind::Fn(.., ref generics, _) => {
if let Some(no_mangle_attr) = attr::find_by_name(&it.attrs, sym::no_mangle) {
for param in &generics.params {
for param in generics.params {
match param.kind {
GenericParamKind::Lifetime { .. } => {}
GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => {
@ -1663,7 +1663,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ExplicitOutlivesRequirements {
let mut bound_count = 0;
let mut lint_spans = Vec::new();
for param in &hir_generics.params {
for param in hir_generics.params {
let has_lifetime_bounds = param.bounds.iter().any(|bound| {
if let hir::GenericBound::Outlives(_) = bound { true } else { false }
});

2
src/librustc_metadata/rmeta/encoder.rs
View file

@ -1569,7 +1569,7 @@ impl EncodeContext<'tcx> {
}
fn encode_info_for_generics(&mut self, generics: &hir::Generics<'tcx>) {
for param in &generics.params {
for param in generics.params {
let def_id = self.tcx.hir().local_def_id(param.hir_id);
match param.kind {
GenericParamKind::Lifetime { .. } => continue,

2
src/librustc_mir/borrow_check/diagnostics/region_name.rs
View file

@ -650,7 +650,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
args: &'hir hir::GenericArgs<'hir>,
search_stack: &mut Vec<(Ty<'tcx>, &'hir hir::Ty<'hir>)>,
) -> Option<&'hir hir::Lifetime> {
for (kind, hir_arg) in substs.iter().zip(&args.args) {
for (kind, hir_arg) in substs.iter().zip(args.args) {
match (kind.unpack(), hir_arg) {
(GenericArgKind::Lifetime(r), hir::GenericArg::Lifetime(lt)) => {
if r.to_region_vid() == needle_fr {

2
src/librustc_mir/monomorphize/collector.rs
View file

@ -1132,7 +1132,7 @@ fn create_mono_items_for_default_impls<'tcx>(
) {
match item.kind {
hir::ItemKind::Impl(_, _, _, ref generics, .., ref impl_item_refs) => {
for param in &generics.params {
for param in generics.params {
match param.kind {
hir::GenericParamKind::Lifetime { .. } => {}
hir::GenericParamKind::Type { .. } | hir::GenericParamKind::Const { .. } => {

2
src/librustc_privacy/lib.rs
View file

@ -1653,7 +1653,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> {
}
fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) {
for param in &generics.params {
for param in generics.params {
for bound in param.bounds {
self.check_generic_bound(bound);
}

7
src/librustc_typeck/astconv.rs
View file

@ -6,7 +6,7 @@ use crate::hir::def::{CtorOf, DefKind, Res};
use crate::hir::def_id::DefId;
use crate::hir::print;
use crate::hir::ptr::P;
use crate::hir::{self, ExprKind, GenericArg, GenericArgs, HirVec};
use crate::hir::{self, ExprKind, GenericArg, GenericArgs};
use crate::lint;
use crate::middle::lang_items::SizedTraitLangItem;
use crate::middle::resolve_lifetime as rl;
@ -255,8 +255,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
seg: &hir::PathSegment<'_>,
is_method_call: bool,
) -> bool {
let empty_args =
P(hir::GenericArgs { args: HirVec::new(), bindings: &[], parenthesized: false });
let empty_args = P(hir::GenericArgs { args: &[], bindings: &[], parenthesized: false });
let suppress_mismatch = Self::check_impl_trait(tcx, seg, &def);
Self::check_generic_arg_count(
tcx,
@ -2278,7 +2277,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
let mut has_err = false;
for segment in segments {
let (mut err_for_lt, mut err_for_ty, mut err_for_ct) = (false, false, false);
for arg in &segment.generic_args().args {
for arg in segment.generic_args().args {
let (span, kind) = match arg {
hir::GenericArg::Lifetime(lt) => {
if err_for_lt {

2
src/librustc_typeck/coherence/orphan.rs
View file

@ -83,7 +83,7 @@ impl ItemLikeVisitor<'v> for OrphanChecker<'tcx> {
}
Err(traits::OrphanCheckErr::UncoveredTy(param_ty, local_type)) => {
let mut sp = sp;
for param in &generics.params {
for param in generics.params {
if param.name.ident().to_string() == param_ty.to_string() {
sp = param.span;
}

6
src/librustc_typeck/collect.rs
View file

@ -117,7 +117,7 @@ impl Visitor<'tcx> for CollectItemTypesVisitor<'tcx> {
}
fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) {
for param in &generics.params {
for param in generics.params {
match param.kind {
hir::GenericParamKind::Lifetime { .. } => {}
hir::GenericParamKind::Type { default: Some(_), .. } => {
@ -860,7 +860,7 @@ fn has_late_bound_regions<'tcx>(tcx: TyCtxt<'tcx>, node: Node<'tcx>) -> Option<S
outer_index: ty::INNERMOST,
has_late_bound_regions: None,
};
for param in &generics.params {
for param in generics.params {
if let GenericParamKind::Lifetime { .. } = param.kind {
if tcx.is_late_bound(param.hir_id) {
return Some(param.span);
@ -2102,7 +2102,7 @@ fn explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicat
// Collect the predicates that were written inline by the user on each
// type parameter (e.g., `<T: Foo>`).
for param in &ast_generics.params {
for param in ast_generics.params {
if let GenericParamKind::Type { .. } = param.kind {
let name = param.name.ident().name;
let param_ty = ty::ParamTy::new(index, name).to_ty(tcx);