bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rename structures in ast

Browse source
This commit is contained in:
varkor 2018-05-27 20:07:09 +01:00
parent f457b3d10a
commit 3bcb006fd9
23 changed files with 136 additions and 136 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -325,7 +325,7 @@ impl<'a> LoweringContext<'a> {
.params
.iter()
.filter(|param| match param.kind {
ast::GenericParamKindAST::Lifetime { .. } => true,
ast::GenericParamKind::Lifetime { .. } => true,
_ => false,
})
.count();
@ -758,13 +758,13 @@ impl<'a> LoweringContext<'a> {
// This is used to track which lifetimes have already been defined, and
// which are new in-band lifetimes that need to have a definition created
// for them.
fn with_in_scope_lifetime_defs<T, F>(&mut self, params: &Vec<GenericParamAST>, f: F) -> T
fn with_in_scope_lifetime_defs<T, F>(&mut self, params: &Vec<GenericParam>, f: F) -> T
where
F: FnOnce(&mut LoweringContext) -> T,
{
let old_len = self.in_scope_lifetimes.len();
let lt_def_names = params.iter().filter_map(|param| match param.kind {
GenericParamKindAST::Lifetime { .. } => Some(param.ident.name),
GenericParamKind::Lifetime { .. } => Some(param.ident.name),
_ => None,
});
self.in_scope_lifetimes.extend(lt_def_names);
@ -1044,12 +1044,12 @@ impl<'a> LoweringContext<'a> {
}
fn lower_generic_arg(&mut self,
arg: &ast::GenericArgAST,
arg: &ast::GenericArg,
itctx: ImplTraitContext)
-> hir::GenericArg {
match arg {
ast::GenericArgAST::Lifetime(lt) => GenericArg::Lifetime(self.lower_lifetime(&lt)),
ast::GenericArgAST::Type(ty) => GenericArg::Type(self.lower_ty(&ty, itctx)),
ast::GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.lower_lifetime(&lt)),
ast::GenericArg::Type(ty) => GenericArg::Type(self.lower_ty(&ty, itctx)),
}
}
@ -1745,7 +1745,7 @@ impl<'a> LoweringContext<'a> {
) -> (hir::GenericArgs, bool) {
let &AngleBracketedArgs { ref args, ref bindings, .. } = data;
let has_types = args.iter().any(|arg| match arg {
GenericArgAST::Type(_) => true,
ast::GenericArg::Type(_) => true,
_ => false,
});
(hir::GenericArgs {
@ -1934,7 +1934,7 @@ impl<'a> LoweringContext<'a> {
fn lower_generic_params(
&mut self,
params: &Vec<GenericParamAST>,
params: &Vec<GenericParam>,
add_bounds: &NodeMap<Vec<TyParamBound>>,
itctx: ImplTraitContext,
) -> hir::HirVec<hir::GenericParam> {
@ -1942,12 +1942,12 @@ impl<'a> LoweringContext<'a> {
}
fn lower_generic_param(&mut self,
param: &GenericParamAST,
param: &GenericParam,
add_bounds: &NodeMap<Vec<TyParamBound>>,
itctx: ImplTraitContext)
-> hir::GenericParam {
match param.kind {
GenericParamKindAST::Lifetime { ref bounds, ref lifetime, .. } => {
GenericParamKind::Lifetime { ref bounds, ref lifetime, .. } => {
let was_collecting_in_band = self.is_collecting_in_band_lifetimes;
self.is_collecting_in_band_lifetimes = false;
@ -1968,7 +1968,7 @@ impl<'a> LoweringContext<'a> {
param
}
GenericParamKindAST::Type { ref bounds, ref default } => {
GenericParamKind::Type { ref bounds, ref default } => {
let mut name = self.lower_ident(param.ident);
// Don't expose `Self` (recovered "keyword used as ident" parse error).
@ -2044,7 +2044,7 @@ impl<'a> LoweringContext<'a> {
{
for param in &generics.params {
match param.kind {
GenericParamKindAST::Type { .. } => {
GenericParamKind::Type { .. } => {
if node_id == param.id {
add_bounds.entry(param.id)
.or_insert(Vec::new())

6
src/librustc/hir/map/def_collector.rs
View file

@ -170,11 +170,11 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
}
}
fn visit_generic_param(&mut self, param: &'a GenericParamAST) {
fn visit_generic_param(&mut self, param: &'a GenericParam) {
let name = param.ident.name.as_interned_str();
let def_path_data = match param.kind {
GenericParamKindAST::Lifetime { .. } => DefPathData::LifetimeParam(name),
GenericParamKindAST::Type { .. } => DefPathData::TypeParam(name),
GenericParamKind::Lifetime { .. } => DefPathData::LifetimeParam(name),
GenericParamKind::Type { .. } => DefPathData::TypeParam(name),
};
self.create_def(param.id, def_path_data, REGULAR_SPACE, param.ident.span);

2
src/librustc/lint/context.rs
View file

@ -990,7 +990,7 @@ impl<'a> ast_visit::Visitor<'a> for EarlyContext<'a> {
run_lints!(self, check_expr_post, early_passes, e);
}
fn visit_generic_param(&mut self, param: &'a ast::GenericParamAST) {
fn visit_generic_param(&mut self, param: &'a ast::GenericParam) {
run_lints!(self, check_generic_param, early_passes, param);
ast_visit::walk_generic_param(self, param);
}

2
src/librustc/lint/mod.rs
View file

@ -254,7 +254,7 @@ pub trait EarlyLintPass: LintPass {
fn check_expr(&mut self, _: &EarlyContext, _: &ast::Expr) { }
fn check_expr_post(&mut self, _: &EarlyContext, _: &ast::Expr) { }
fn check_ty(&mut self, _: &EarlyContext, _: &ast::Ty) { }
fn check_generic_param(&mut self, _: &EarlyContext, _: &ast::GenericParamAST) { }
fn check_generic_param(&mut self, _: &EarlyContext, _: &ast::GenericParam) { }
fn check_generics(&mut self, _: &EarlyContext, _: &ast::Generics) { }
fn check_where_predicate(&mut self, _: &EarlyContext, _: &ast::WherePredicate) { }
fn check_poly_trait_ref(&mut self, _: &EarlyContext, _: &ast::PolyTraitRef,

2
src/librustc_driver/pretty.rs
View file

@ -681,7 +681,7 @@ impl<'a> ReplaceBodyWithLoop<'a> {
None => false,
Some(&ast::GenericArgs::AngleBracketed(ref data)) => {
let types = data.args.iter().filter_map(|arg| match arg {
ast::GenericArgAST::Type(ty) => Some(ty),
ast::GenericArg::Type(ty) => Some(ty),
_ => None,
});
any_involves_impl_trait(types.into_iter()) ||

16
src/librustc_passes/ast_validation.rs
View file

@ -138,11 +138,11 @@ impl<'a> AstValidator<'a> {
}
}
fn check_late_bound_lifetime_defs(&self, params: &Vec<GenericParamAST>) {
fn check_late_bound_lifetime_defs(&self, params: &Vec<GenericParam>) {
// Check only lifetime parameters are present and that the lifetime
// parameters that are present have no bounds.
let non_lt_param_spans: Vec<_> = params.iter().filter_map(|param| match param.kind {
GenericParamKindAST::Lifetime { ref bounds, .. } => {
GenericParamKind::Lifetime { ref bounds, .. } => {
if !bounds.is_empty() {
let spans: Vec<_> = bounds.iter().map(|b| b.ident.span).collect();
self.err_handler()
@ -329,8 +329,8 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
ItemKind::TraitAlias(Generics { ref params, .. }, ..) => {
for param in params {
match param.kind {
GenericParamKindAST::Lifetime { .. } => {}
GenericParamKindAST::Type { ref bounds, ref default, .. } => {
GenericParamKind::Lifetime { .. } => {}
GenericParamKind::Type { ref bounds, ref default, .. } => {
if !bounds.is_empty() {
self.err_handler()
.span_err(param.ident.span, "type parameters on the left \
@ -404,12 +404,12 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
let mut seen_default = None;
for param in &generics.params {
match (&param.kind, seen_non_lifetime_param) {
(GenericParamKindAST::Lifetime { .. }, true) => {
(GenericParamKind::Lifetime { .. }, true) => {
self.err_handler()
.span_err(param.ident.span, "lifetime parameters must be leading");
},
(GenericParamKindAST::Lifetime { .. }, false) => {}
(GenericParamKindAST::Type { ref default, .. }, _) => {
(GenericParamKind::Lifetime { .. }, false) => {}
(GenericParamKind::Type { ref default, .. }, _) => {
seen_non_lifetime_param = true;
if default.is_some() {
seen_default = Some(param.ident.span);
@ -514,7 +514,7 @@ impl<'a> Visitor<'a> for NestedImplTraitVisitor<'a> {
match *generic_args {
GenericArgs::AngleBracketed(ref data) => {
data.args.iter().for_each(|arg| match arg {
GenericArgAST::Type(ty) => self.visit_ty(ty),
GenericArg::Type(ty) => self.visit_ty(ty),
_ => {}
});
for type_binding in &data.bindings {

12
src/librustc_resolve/lib.rs
View file

@ -56,7 +56,7 @@ use syntax::util::lev_distance::find_best_match_for_name;
use syntax::visit::{self, FnKind, Visitor};
use syntax::attr;
use syntax::ast::{Arm, BindingMode, Block, Crate, Expr, ExprKind};
use syntax::ast::{FnDecl, ForeignItem, ForeignItemKind, GenericParamKindAST, Generics};
use syntax::ast::{FnDecl, ForeignItem, ForeignItemKind, GenericParamKind, Generics};
use syntax::ast::{Item, ItemKind, ImplItem, ImplItemKind};
use syntax::ast::{Label, Local, Mutability, Pat, PatKind, Path};
use syntax::ast::{QSelf, TraitItemKind, TraitRef, Ty, TyKind};
@ -800,8 +800,8 @@ impl<'a, 'tcx> Visitor<'tcx> for Resolver<'a> {
let mut found_default = false;
default_ban_rib.bindings.extend(generics.params.iter()
.filter_map(|param| match param.kind {
GenericParamKindAST::Lifetime { .. } => None,
GenericParamKindAST::Type { ref default, .. } => {
GenericParamKind::Lifetime { .. } => None,
GenericParamKind::Type { ref default, .. } => {
if found_default || default.is_some() {
found_default = true;
return Some((Ident::with_empty_ctxt(param.ident.name), Def::Err));
@ -812,8 +812,8 @@ impl<'a, 'tcx> Visitor<'tcx> for Resolver<'a> {
for param in &generics.params {
match param.kind {
GenericParamKindAST::Lifetime { .. } => self.visit_generic_param(param),
GenericParamKindAST::Type { ref bounds, ref default, .. } => {
GenericParamKind::Lifetime { .. } => self.visit_generic_param(param),
GenericParamKind::Type { ref bounds, ref default, .. } => {
for bound in bounds {
self.visit_ty_param_bound(bound);
}
@ -2208,7 +2208,7 @@ impl<'a> Resolver<'a> {
let mut function_type_rib = Rib::new(rib_kind);
let mut seen_bindings = FxHashMap();
generics.params.iter().for_each(|param| match param.kind {
GenericParamKindAST::Type { .. } => {
GenericParamKind::Type { .. } => {
let ident = param.ident.modern();
debug!("with_type_parameter_rib: {}", param.id);

12
src/librustc_save_analysis/dump_visitor.rs
View file

@ -371,8 +371,8 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> {
) {
for param in &generics.params {
match param.kind {
ast::GenericParamKindAST::Lifetime { .. } => {}
ast::GenericParamKindAST::Type { .. } => {
ast::GenericParamKind::Lifetime { .. } => {}
ast::GenericParamKind::Type { .. } => {
let param_ss = param.ident.span;
let name = escape(self.span.snippet(param_ss));
// Append $id to name to make sure each one is unique.
@ -827,7 +827,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> {
match **generic_args {
ast::GenericArgs::AngleBracketed(ref data) => {
data.args.iter().for_each(|arg| match arg {
ast::GenericArgAST::Type(ty) => self.visit_ty(ty),
ast::GenericArg::Type(ty) => self.visit_ty(ty),
_ => {}
});
}
@ -914,7 +914,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> {
if let Some(ref generic_args) = seg.args {
if let ast::GenericArgs::AngleBracketed(ref data) = **generic_args {
data.args.iter().for_each(|arg| match arg {
ast::GenericArgAST::Type(ty) => self.visit_ty(ty),
ast::GenericArg::Type(ty) => self.visit_ty(ty),
_ => {}
});
}
@ -1486,8 +1486,8 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> Visitor<'l> for DumpVisitor<'l, 'tc
fn visit_generics(&mut self, generics: &'l ast::Generics) {
generics.params.iter().for_each(|param| match param.kind {
ast::GenericParamKindAST::Lifetime { .. } => {}
ast::GenericParamKindAST::Type { ref bounds, ref default, .. } => {
ast::GenericParamKind::Lifetime { .. } => {}
ast::GenericParamKind::Type { ref bounds, ref default, .. } => {
for bound in bounds {
if let ast::TraitTyParamBound(ref trait_ref, _) = *bound {
self.process_path(trait_ref.trait_ref.ref_id, &trait_ref.trait_ref.path)

4
src/librustc_save_analysis/lib.rs
View file

@ -935,8 +935,8 @@ fn make_signature(decl: &ast::FnDecl, generics: &ast::Generics) -> String {
.params
.iter()
.map(|param| match param.kind {
ast::GenericParamKindAST::Lifetime { .. } => param.ident.name.to_string(),
ast::GenericParamKindAST::Type { .. } => param.ident.to_string(),
ast::GenericParamKind::Lifetime { .. } => param.ident.name.to_string(),
ast::GenericParamKind::Type { .. } => param.ident.to_string(),
})
.collect::<Vec<_>>()
.join(", "));

6
src/librustc_save_analysis/sig.rs
View file

@ -224,7 +224,7 @@ impl Sig for ast::Ty {
text.push_str(&f.generic_params
.iter()
.filter_map(|param| match param.kind {
ast::GenericParamKindAST::Lifetime { .. } => {
ast::GenericParamKind::Lifetime { .. } => {
Some(param.ident.to_string())
}
_ => None,
@ -624,7 +624,7 @@ impl Sig for ast::Generics {
end: offset + text.len() + param_text.len(),
});
match param.kind {
ast::GenericParamKindAST::Lifetime { ref bounds, .. } => {
ast::GenericParamKind::Lifetime { ref bounds, .. } => {
if !bounds.is_empty() {
param_text.push_str(": ");
let bounds = bounds.iter()
@ -635,7 +635,7 @@ impl Sig for ast::Generics {
// FIXME add lifetime bounds refs.
}
}
ast::GenericParamKindAST::Type { ref bounds, .. } => {
ast::GenericParamKind::Type { ref bounds, .. } => {
if !bounds.is_empty() {
param_text.push_str(": ");
param_text.push_str(&pprust::bounds_to_string(bounds));

20
src/libsyntax/ast.rs
View file

@ -160,7 +160,7 @@ impl GenericArgs {
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum GenericArgAST {
pub enum GenericArg {
Lifetime(Lifetime),
Type(P<Ty>),
}
@ -171,7 +171,7 @@ pub struct AngleBracketedArgs {
/// Overall span
pub span: Span,
/// The arguments for this path segment.
pub args: Vec<GenericArgAST>,
pub args: Vec<GenericArg>,
/// Bindings (equality constraints) on associated types, if present.
///
/// E.g., `Foo<A=Bar>`.
@ -299,7 +299,7 @@ pub enum TraitBoundModifier {
pub type TyParamBounds = Vec<TyParamBound>;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum GenericParamKindAST {
pub enum GenericParamKind {
/// A lifetime definition, e.g. `'a: 'b+'c+'d`.
Lifetime {
bounds: Vec<Lifetime>,
@ -312,19 +312,19 @@ pub enum GenericParamKindAST {
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct GenericParamAST {
pub struct GenericParam {
pub ident: Ident,
pub id: NodeId,
pub attrs: ThinVec<Attribute>,
pub kind: GenericParamKindAST,
pub kind: GenericParamKind,
}
/// Represents lifetime, type and const parameters attached to a declaration of
/// a function, enum, trait, etc.
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct Generics {
pub params: Vec<GenericParamAST>,
pub params: Vec<GenericParam>,
pub where_clause: WhereClause,
pub span: Span,
}
@ -380,7 +380,7 @@ impl WherePredicate {
pub struct WhereBoundPredicate {
pub span: Span,
/// Any generics from a `for` binding
pub bound_generic_params: Vec<GenericParamAST>,
pub bound_generic_params: Vec<GenericParam>,
/// The type being bounded
pub bounded_ty: P<Ty>,
/// Trait and lifetime bounds (`Clone+Send+'static`)
@ -1512,7 +1512,7 @@ impl fmt::Debug for Ty {
pub struct BareFnTy {
pub unsafety: Unsafety,
pub abi: Abi,
pub generic_params: Vec<GenericParamAST>,
pub generic_params: Vec<GenericParam>,
pub decl: P<FnDecl>
}
@ -1891,7 +1891,7 @@ pub struct TraitRef {
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct PolyTraitRef {
/// The `'a` in `<'a> Foo<&'a T>`
pub bound_generic_params: Vec<GenericParamAST>,
pub bound_generic_params: Vec<GenericParam>,
/// The `Foo<&'a T>` in `<'a> Foo<&'a T>`
pub trait_ref: TraitRef,
@ -1900,7 +1900,7 @@ pub struct PolyTraitRef {
}
impl PolyTraitRef {
pub fn new(generic_params: Vec<GenericParamAST>, path: Path, span: Span) -> Self {
pub fn new(generic_params: Vec<GenericParam>, path: Path, span: Span) -> Self {
PolyTraitRef {
bound_generic_params: generic_params,
trait_ref: TraitRef { path: path, ref_id: DUMMY_NODE_ID },

26
src/libsyntax/ext/build.rs
View file

@ -31,7 +31,7 @@ pub trait AstBuilder {
fn path_all(&self, sp: Span,
global: bool,
idents: Vec<ast::Ident>,
args: Vec<ast::GenericArgAST>,
args: Vec<ast::GenericArg>,
bindings: Vec<ast::TypeBinding>)
-> ast::Path;
@ -42,7 +42,7 @@ pub trait AstBuilder {
fn qpath_all(&self, self_type: P<ast::Ty>,
trait_path: ast::Path,
ident: ast::Ident,
args: Vec<ast::GenericArgAST>,
args: Vec<ast::GenericArg>,
bindings: Vec<ast::TypeBinding>)
-> (ast::QSelf, ast::Path);
@ -69,7 +69,7 @@ pub trait AstBuilder {
id: ast::Ident,
attrs: Vec<ast::Attribute>,
bounds: ast::TyParamBounds,
default: Option<P<ast::Ty>>) -> ast::GenericParamAST;
default: Option<P<ast::Ty>>) -> ast::GenericParam;
fn trait_ref(&self, path: ast::Path) -> ast::TraitRef;
fn poly_trait_ref(&self, span: Span, path: ast::Path) -> ast::PolyTraitRef;
@ -80,7 +80,7 @@ pub trait AstBuilder {
ident: ast::Ident,
attrs: Vec<ast::Attribute>,
bounds: Vec<ast::Lifetime>)
-> ast::GenericParamAST;
-> ast::GenericParam;
// statements
fn stmt_expr(&self, expr: P<ast::Expr>) -> ast::Stmt;
@ -314,7 +314,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
span: Span,
global: bool,
mut idents: Vec<ast::Ident> ,
args: Vec<ast::GenericArgAST>,
args: Vec<ast::GenericArg>,
bindings: Vec<ast::TypeBinding> )
-> ast::Path {
let last_ident = idents.pop().unwrap();
@ -356,7 +356,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
self_type: P<ast::Ty>,
trait_path: ast::Path,
ident: ast::Ident,
args: Vec<ast::GenericArgAST>,
args: Vec<ast::GenericArg>,
bindings: Vec<ast::TypeBinding>)
-> (ast::QSelf, ast::Path) {
let mut path = trait_path;
@ -424,7 +424,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
self.path_all(DUMMY_SP,
true,
self.std_path(&["option", "Option"]),
vec![ast::GenericArgAST::Type(ty)],
vec![ast::GenericArg::Type(ty)],
Vec::new()))
}
@ -437,12 +437,12 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
ident: ast::Ident,
attrs: Vec<ast::Attribute>,
bounds: ast::TyParamBounds,
default: Option<P<ast::Ty>>) -> ast::GenericParamAST {
ast::GenericParamAST {
default: Option<P<ast::Ty>>) -> ast::GenericParam {
ast::GenericParam {
ident: ident.with_span_pos(span),
id: ast::DUMMY_NODE_ID,
attrs: attrs.into(),
kind: ast::GenericParamKindAST::Type {
kind: ast::GenericParamKind::Type {
bounds,
default,
}
@ -477,13 +477,13 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
ident: ast::Ident,
attrs: Vec<ast::Attribute>,
bounds: Vec<ast::Lifetime>)
-> ast::GenericParamAST {
-> ast::GenericParam {
let lifetime = self.lifetime(span, ident);
ast::GenericParamAST {
ast::GenericParam {
ident: lifetime.ident,
id: lifetime.id,
attrs: attrs.into(),
kind: ast::GenericParamKindAST::Lifetime {
kind: ast::GenericParamKind::Lifetime {
lifetime,
bounds,
}

24
src/libsyntax/fold.rs
View file

@ -132,10 +132,10 @@ pub trait Folder : Sized {
noop_fold_exprs(es, self)
}
fn fold_generic_arg(&mut self, arg: GenericArgAST) -> GenericArgAST {
fn fold_generic_arg(&mut self, arg: GenericArg) -> GenericArg {
match arg {
GenericArgAST::Lifetime(lt) => GenericArgAST::Lifetime(self.fold_lifetime(lt)),
GenericArgAST::Type(ty) => GenericArgAST::Type(self.fold_ty(ty)),
GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.fold_lifetime(lt)),
GenericArg::Type(ty) => GenericArg::Type(self.fold_ty(ty)),
}
}
@ -244,11 +244,11 @@ pub trait Folder : Sized {
noop_fold_ty_param(tp, self)
}
fn fold_generic_param(&mut self, param: GenericParamAST) -> GenericParamAST {
fn fold_generic_param(&mut self, param: GenericParam) -> GenericParam {
noop_fold_generic_param(param, self)
}
fn fold_generic_params(&mut self, params: Vec<GenericParamAST>) -> Vec<GenericParamAST> {
fn fold_generic_params(&mut self, params: Vec<GenericParam>) -> Vec<GenericParam> {
noop_fold_generic_params(params, self)
}
@ -687,11 +687,11 @@ pub fn noop_fold_ty_param_bound<T>(tpb: TyParamBound, fld: &mut T)
}
}
pub fn noop_fold_generic_param<T: Folder>(param: GenericParamAST, fld: &mut T) -> GenericParamAST {
match param {
GenericParamAST::Lifetime { bounds, lifetime } => {
pub fn noop_fold_generic_param<T: Folder>(param: GenericParam, fld: &mut T) -> GenericParam {
match param.kind {
GenericParamKind::Lifetime { bounds, lifetime } => {
let attrs: Vec<_> = param.attrs.into();
GenericParamAST::Lifetime(LifetimeDef {
GenericParamKind::Lifetime(LifetimeDef {
attrs: attrs.into_iter()
.flat_map(|x| fld.fold_attribute(x).into_iter())
.collect::<Vec<_>>()
@ -703,14 +703,14 @@ pub fn noop_fold_generic_param<T: Folder>(param: GenericParamAST, fld: &mut T) -
bounds: bounds.move_map(|l| noop_fold_lifetime(l, fld)),
})
}
GenericParamAST::Type { .. } => GenericParamAST::Type(fld.fold_ty_param(param)),
GenericParamKind::Type { .. } => GenericParamKind::Type(fld.fold_ty_param(param)),
}
}
pub fn noop_fold_generic_params<T: Folder>(
params: Vec<GenericParamAST>,
params: Vec<GenericParam>,
fld: &mut T
) -> Vec<GenericParamAST> {
) -> Vec<GenericParam> {
params.move_map(|p| fld.fold_generic_param(p))
}

28
src/libsyntax/parse/parser.rs
View file

@ -21,8 +21,8 @@ use ast::EnumDef;
use ast::{Expr, ExprKind, RangeLimits};
use ast::{Field, FnDecl};
use ast::{ForeignItem, ForeignItemKind, FunctionRetTy};
use ast::{GenericParamAST, GenericParamKindAST};
use ast::GenericArgAST;
use ast::{GenericParam, GenericParamKind};
use ast::GenericArg;
use ast::{Ident, ImplItem, IsAuto, Item, ItemKind};
use ast::{Label, Lifetime, Lit, LitKind};
use ast::Local;
@ -1246,7 +1246,7 @@ impl<'a> Parser<'a> {
}
/// parse a TyKind::BareFn type:
fn parse_ty_bare_fn(&mut self, generic_params: Vec<GenericParamAST>) -> PResult<'a, TyKind> {
fn parse_ty_bare_fn(&mut self, generic_params: Vec<GenericParam>) -> PResult<'a, TyKind> {
/*
[unsafe] [extern "ABI"] fn (S) -> T
@ -1563,7 +1563,7 @@ impl<'a> Parser<'a> {
Ok(P(ty))
}
fn parse_remaining_bounds(&mut self, generic_params: Vec<GenericParamAST>, path: ast::Path,
fn parse_remaining_bounds(&mut self, generic_params: Vec<GenericParam>, path: ast::Path,
lo: Span, parse_plus: bool) -> PResult<'a, TyKind> {
let poly_trait_ref = PolyTraitRef::new(generic_params, path, lo.to(self.prev_span));
let mut bounds = vec![TraitTyParamBound(poly_trait_ref, TraitBoundModifier::None)];
@ -4805,7 +4805,7 @@ impl<'a> Parser<'a> {
/// Matches typaram = IDENT (`?` unbound)? optbounds ( EQ ty )?
fn parse_ty_param(&mut self,
preceding_attrs: Vec<Attribute>)
-> PResult<'a, GenericParamAST> {
-> PResult<'a, GenericParam> {
let ident = self.parse_ident()?;
// Parse optional colon and param bounds.
@ -4821,11 +4821,11 @@ impl<'a> Parser<'a> {
None
};
Ok(GenericParamAST {
Ok(GenericParam {
ident,
attrs: preceding_attrs.into(),
id: ast::DUMMY_NODE_ID,
kind: GenericParamKindAST::Type {
kind: GenericParamKind::Type {
bounds,
default,
}
@ -4859,7 +4859,7 @@ impl<'a> Parser<'a> {
/// Parses (possibly empty) list of lifetime and type parameters, possibly including
/// trailing comma and erroneous trailing attributes.
crate fn parse_generic_params(&mut self) -> PResult<'a, Vec<ast::GenericParamAST>> {
crate fn parse_generic_params(&mut self) -> PResult<'a, Vec<ast::GenericParam>> {
let mut params = Vec::new();
let mut seen_ty_param = false;
loop {
@ -4872,11 +4872,11 @@ impl<'a> Parser<'a> {
} else {
Vec::new()
};
params.push(ast::GenericParamAST {
params.push(ast::GenericParam {
ident: lifetime.ident,
id: lifetime.id,
attrs: attrs.into(),
kind: ast::GenericParamKindAST::Lifetime {
kind: ast::GenericParamKind::Lifetime {
lifetime,
bounds,
}
@ -4937,7 +4937,7 @@ impl<'a> Parser<'a> {
/// Parses (possibly empty) list of lifetime and type arguments and associated type bindings,
/// possibly including trailing comma.
fn parse_generic_args(&mut self)
-> PResult<'a, (Vec<GenericArgAST>, Vec<TypeBinding>)> {
-> PResult<'a, (Vec<GenericArg>, Vec<TypeBinding>)> {
let mut args = Vec::new();
let mut bindings = Vec::new();
let mut seen_type = false;
@ -4945,7 +4945,7 @@ impl<'a> Parser<'a> {
loop {
if self.check_lifetime() && self.look_ahead(1, |t| !t.is_like_plus()) {
// Parse lifetime argument.
args.push(GenericArgAST::Lifetime(self.expect_lifetime()));
args.push(GenericArg::Lifetime(self.expect_lifetime()));
if seen_type || seen_binding {
self.span_err(self.prev_span,
"lifetime parameters must be declared prior to type parameters");
@ -4970,7 +4970,7 @@ impl<'a> Parser<'a> {
self.span_err(ty_param.span,
"type parameters must be declared prior to associated type bindings");
}
args.push(GenericArgAST::Type(ty_param));
args.push(GenericArg::Type(ty_param));
seen_type = true;
} else {
break
@ -5692,7 +5692,7 @@ impl<'a> Parser<'a> {
Ok((keywords::Invalid.ident(), item_kind, Some(attrs)))
}
fn parse_late_bound_lifetime_defs(&mut self) -> PResult<'a, Vec<GenericParamAST>> {
fn parse_late_bound_lifetime_defs(&mut self) -> PResult<'a, Vec<GenericParam>> {
if self.eat_keyword(keywords::For) {
self.expect_lt()?;
let params = self.parse_generic_params()?;

20
src/libsyntax/print/pprust.rs
View file

@ -13,7 +13,7 @@ pub use self::AnnNode::*;
use rustc_target::spec::abi::{self, Abi};
use ast::{self, BlockCheckMode, PatKind, RangeEnd, RangeSyntax};
use ast::{SelfKind, RegionTyParamBound, TraitTyParamBound, TraitBoundModifier};
use ast::{Attribute, MacDelimiter, GenericArgAST};
use ast::{Attribute, MacDelimiter, GenericArg};
use util::parser::{self, AssocOp, Fixity};
use attr;
use codemap::{self, CodeMap};
@ -344,7 +344,7 @@ pub fn trait_item_to_string(i: &ast::TraitItem) -> String {
to_string(|s| s.print_trait_item(i))
}
pub fn generic_params_to_string(generic_params: &[ast::GenericParamAST]) -> String {
pub fn generic_params_to_string(generic_params: &[ast::GenericParam]) -> String {
to_string(|s| s.print_generic_params(generic_params))
}
@ -1017,10 +1017,10 @@ impl<'a> State<'a> {
Ok(())
}
pub fn print_generic_arg(&mut self, generic_arg: &GenericArgAST) -> io::Result<()> {
pub fn print_generic_arg(&mut self, generic_arg: &GenericArg) -> io::Result<()> {
match generic_arg {
GenericArgAST::Lifetime(lt) => self.print_lifetime(lt),
GenericArgAST::Type(ty) => self.print_type(ty),
GenericArg::Lifetime(lt) => self.print_lifetime(lt),
GenericArg::Type(ty) => self.print_type(ty),
}
}
@ -1443,7 +1443,7 @@ impl<'a> State<'a> {
fn print_formal_generic_params(
&mut self,
generic_params: &[ast::GenericParamAST]
generic_params: &[ast::GenericParam]
) -> io::Result<()> {
if !generic_params.is_empty() {
self.s.word("for")?;
@ -2869,7 +2869,7 @@ impl<'a> State<'a> {
pub fn print_generic_params(
&mut self,
generic_params: &[ast::GenericParamAST]
generic_params: &[ast::GenericParam]
) -> io::Result<()> {
if generic_params.is_empty() {
return Ok(());
@ -2879,11 +2879,11 @@ impl<'a> State<'a> {
self.commasep(Inconsistent, &generic_params, |s, param| {
match param.kind {
ast::GenericParamKindAST::Lifetime { ref bounds, ref lifetime } => {
ast::GenericParamKind::Lifetime { ref bounds, ref lifetime } => {
s.print_outer_attributes_inline(&param.attrs)?;
s.print_lifetime_bounds(lifetime, bounds)
},
ast::GenericParamKindAST::Type { ref bounds, ref default } => {
ast::GenericParamKind::Type { ref bounds, ref default } => {
s.print_outer_attributes_inline(&param.attrs)?;
s.print_ident(param.ident)?;
s.print_bounds(":", bounds)?;
@ -3045,7 +3045,7 @@ impl<'a> State<'a> {
unsafety: ast::Unsafety,
decl: &ast::FnDecl,
name: Option<ast::Ident>,
generic_params: &Vec<ast::GenericParamAST>)
generic_params: &Vec<ast::GenericParam>)
-> io::Result<()> {
self.ibox(INDENT_UNIT)?;
if !generic_params.is_empty() {

2
src/libsyntax/util/node_count.rs
View file

@ -71,7 +71,7 @@ impl<'ast> Visitor<'ast> for NodeCounter {
self.count += 1;
walk_ty(self, t)
}
fn visit_generic_param(&mut self, param: &GenericParamAST) {
fn visit_generic_param(&mut self, param: &GenericParam) {
self.count += 1;
walk_generic_param(self, param)
}

14
src/libsyntax/visit.rs
View file

@ -73,7 +73,7 @@ pub trait Visitor<'ast>: Sized {
fn visit_expr(&mut self, ex: &'ast Expr) { walk_expr(self, ex) }
fn visit_expr_post(&mut self, _ex: &'ast Expr) { }
fn visit_ty(&mut self, t: &'ast Ty) { walk_ty(self, t) }
fn visit_generic_param(&mut self, param: &'ast GenericParamAST) {
fn visit_generic_param(&mut self, param: &'ast GenericParam) {
walk_generic_param(self, param)
}
fn visit_generics(&mut self, g: &'ast Generics) { walk_generics(self, g) }
@ -133,10 +133,10 @@ pub trait Visitor<'ast>: Sized {
fn visit_generic_args(&mut self, path_span: Span, generic_args: &'ast GenericArgs) {
walk_generic_args(self, path_span, generic_args)
}
fn visit_generic_arg(&mut self, generic_arg: &'ast GenericArgAST) {
fn visit_generic_arg(&mut self, generic_arg: &'ast GenericArg) {
match generic_arg {
GenericArgAST::Lifetime(lt) => self.visit_lifetime(lt),
GenericArgAST::Type(ty) => self.visit_ty(ty),
GenericArg::Lifetime(lt) => self.visit_lifetime(lt),
GenericArg::Type(ty) => self.visit_ty(ty),
}
}
fn visit_assoc_type_binding(&mut self, type_binding: &'ast TypeBinding) {
@ -490,14 +490,14 @@ pub fn walk_ty_param_bound<'a, V: Visitor<'a>>(visitor: &mut V, bound: &'a TyPar
}
}
pub fn walk_generic_param<'a, V: Visitor<'a>>(visitor: &mut V, param: &'a GenericParamAST) {
pub fn walk_generic_param<'a, V: Visitor<'a>>(visitor: &mut V, param: &'a GenericParam) {
match param.kind {
GenericParamKindAST::Lifetime { ref bounds, ref lifetime, .. } => {
GenericParamKind::Lifetime { ref bounds, ref lifetime, .. } => {
visitor.visit_ident(param.ident);
walk_list!(visitor, visit_lifetime, bounds);
walk_list!(visitor, visit_attribute, param.attrs.iter());
}
GenericParamKindAST::Type { ref bounds, ref default, .. } => {
GenericParamKind::Type { ref bounds, ref default, .. } => {
visitor.visit_ident(t.ident);
walk_list!(visitor, visit_ty_param_bound, bounds);
walk_list!(visitor, visit_ty, default);

6
src/libsyntax_ext/deriving/clone.rs
View file

@ -13,7 +13,7 @@ use deriving::generic::*;
use deriving::generic::ty::*;
use syntax::ast::{self, Expr, Generics, ItemKind, MetaItem, VariantData};
use syntax::ast::GenericArgAST;
use syntax::ast::GenericArg;
use syntax::attr;
use syntax::ext::base::{Annotatable, ExtCtxt};
use syntax::ext::build::AstBuilder;
@ -50,7 +50,7 @@ pub fn expand_deriving_clone(cx: &mut ExtCtxt,
ItemKind::Enum(_, Generics { ref params, .. }) => {
if attr::contains_name(&annitem.attrs, "rustc_copy_clone_marker") &&
!params.iter().any(|param| match param.kind {
ast::GenericParamKindAST::Type { .. } => true,
ast::GenericParamKind::Type { .. } => true,
_ => false,
})
{
@ -127,7 +127,7 @@ fn cs_clone_shallow(name: &str,
let span = span.with_ctxt(cx.backtrace());
let assert_path = cx.path_all(span, true,
cx.std_path(&["clone", helper_name]),
vec![GenericArgAST::Type(ty)], vec![]);
vec![GenericArg::Type(ty)], vec![]);
stmts.push(cx.stmt_let_type_only(span, cx.ty_path(assert_path)));
}
fn process_variant(cx: &mut ExtCtxt, stmts: &mut Vec<ast::Stmt>, variant: &VariantData) {

4
src/libsyntax_ext/deriving/cmp/eq.rs
View file

@ -12,7 +12,7 @@ use deriving::path_std;
use deriving::generic::*;
use deriving::generic::ty::*;
use syntax::ast::{self, Expr, MetaItem, GenericArgAST};
use syntax::ast::{self, Expr, MetaItem, GenericArg};
use syntax::ext::base::{Annotatable, ExtCtxt};
use syntax::ext::build::AstBuilder;
use syntax::ptr::P;
@ -62,7 +62,7 @@ fn cs_total_eq_assert(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
let span = span.with_ctxt(cx.backtrace());
let assert_path = cx.path_all(span, true,
cx.std_path(&["cmp", helper_name]),
vec![GenericArgAST::Type(ty)], vec![]);
vec![GenericArg::Type(ty)], vec![]);
stmts.push(cx.stmt_let_type_only(span, cx.ty_path(assert_path)));
}
fn process_variant(cx: &mut ExtCtxt, stmts: &mut Vec<ast::Stmt>, variant: &ast::VariantData) {

18
src/libsyntax_ext/deriving/generic/mod.rs
View file

@ -193,7 +193,7 @@ use std::vec;
use rustc_target::spec::abi::Abi;
use syntax::ast::{self, BinOpKind, EnumDef, Expr, Generics, Ident, PatKind};
use syntax::ast::{VariantData, GenericParamKindAST, GenericArgAST};
use syntax::ast::{VariantData, GenericParamKind, GenericArg};
use syntax::attr;
use syntax::ext::base::{Annotatable, ExtCtxt};
use syntax::ext::build::AstBuilder;
@ -423,7 +423,7 @@ impl<'a> TraitDef<'a> {
ast::ItemKind::Enum(_, ref generics) |
ast::ItemKind::Union(_, ref generics) => {
!generics.params.iter().any(|param| match param.kind {
ast::GenericParamKindAST::Type { .. } => true,
ast::GenericParamKind::Type { .. } => true,
_ => false,
})
}
@ -550,8 +550,8 @@ impl<'a> TraitDef<'a> {
// Create the generic parameters
params.extend(generics.params.iter().map(|param| match param.kind {
GenericParamKindAST::Lifetime { .. } => param.clone(),
GenericParamKindAST::Type { bounds: ref ty_bounds, .. } => {
GenericParamKind::Lifetime { .. } => param.clone(),
GenericParamKind::Type { bounds: ref ty_bounds, .. } => {
// I don't think this can be moved out of the loop, since
// a TyParamBound requires an ast id
let mut bounds: Vec<_> =
@ -608,7 +608,7 @@ impl<'a> TraitDef<'a> {
let mut ty_params = params.iter()
.filter_map(|param| match param.kind {
ast::GenericParamKindAST::Type { .. } => Some(param),
ast::GenericParamKind::Type { .. } => Some(param),
_ => None,
})
.peekable();
@ -669,7 +669,7 @@ impl<'a> TraitDef<'a> {
let self_ty_params: Vec<P<ast::Ty>> = generics.params
.iter()
.filter_map(|param| match param.kind {
GenericParamKindAST::Type { .. } => Some(cx.ty_ident(self.span, param.ident)),
GenericParamKind::Type { .. } => Some(cx.ty_ident(self.span, param.ident)),
_ => None,
})
.collect();
@ -677,15 +677,15 @@ impl<'a> TraitDef<'a> {
let self_lifetimes: Vec<ast::Lifetime> = generics.params
.iter()
.filter_map(|param| match param.kind {
GenericParamKindAST::Lifetime { ref lifetime, .. } => Some(*lifetime),
GenericParamKind::Lifetime { ref lifetime, .. } => Some(*lifetime),
_ => None,
})
.collect();
let self_params = self_lifetimes.into_iter()
.map(|lt| GenericArgAST::Lifetime(lt))
.map(|lt| GenericArg::Lifetime(lt))
.chain(self_ty_params.into_iter().map(|ty|
GenericArgAST::Type(ty)))
GenericArg::Type(ty)))
.collect();
// Create the type of `self`.

18
src/libsyntax_ext/deriving/generic/ty.rs
View file

@ -15,7 +15,7 @@ pub use self::PtrTy::*;
pub use self::Ty::*;
use syntax::ast;
use syntax::ast::{Expr, GenericParamKindAST, Generics, Ident, SelfKind, GenericArgAST};
use syntax::ast::{Expr, GenericParamKind, Generics, Ident, SelfKind, GenericArg};
use syntax::ext::base::ExtCtxt;
use syntax::ext::build::AstBuilder;
use syntax::codemap::{respan, DUMMY_SP};
@ -89,8 +89,8 @@ impl<'a> Path<'a> {
let tys: Vec<P<ast::Ty>> =
self.params.iter().map(|t| t.to_ty(cx, span, self_ty, self_generics)).collect();
let params = lt.into_iter()
.map(|lt| GenericArgAST::Lifetime(lt))
.chain(tys.into_iter().map(|ty| GenericArgAST::Type(ty)))
.map(|lt| GenericArg::Lifetime(lt))
.chain(tys.into_iter().map(|ty| GenericArg::Type(ty)))
.collect();
match self.kind {
@ -192,7 +192,7 @@ impl<'a> Ty<'a> {
let ty_params: Vec<P<ast::Ty>> = self_generics.params
.iter()
.filter_map(|param| match param.kind {
GenericParamKindAST::Type { .. } => {
GenericParamKind::Type { .. } => {
Some(cx.ty_ident(span, param.ident))
}
_ => None,
@ -202,15 +202,15 @@ impl<'a> Ty<'a> {
let lifetimes: Vec<ast::Lifetime> = self_generics.params
.iter()
.filter_map(|param| match param.kind {
GenericParamKindAST::Lifetime { ref lifetime, .. } => Some(*lifetime),
GenericParamKind::Lifetime { ref lifetime, .. } => Some(*lifetime),
_ => None,
})
.collect();
let params = lifetimes.into_iter()
.map(|lt| GenericArgAST::Lifetime(lt))
.map(|lt| GenericArg::Lifetime(lt))
.chain(ty_params.into_iter().map(|ty|
GenericArgAST::Type(ty)))
GenericArg::Type(ty)))
.collect();
cx.path_all(span,
@ -234,7 +234,7 @@ fn mk_ty_param(cx: &ExtCtxt,
bounds: &[Path],
self_ident: Ident,
self_generics: &Generics)
-> ast::GenericParamAST {
-> ast::GenericParam {
let bounds = bounds.iter()
.map(|b| {
let path = b.to_path(cx, span, self_ident, self_generics);
@ -244,7 +244,7 @@ fn mk_ty_param(cx: &ExtCtxt,
cx.typaram(span, cx.ident_of(name), attrs.to_owned(), bounds, None)
}
fn mk_generics(params: Vec<ast::GenericParamAST>, span: Span) -> Generics {
fn mk_generics(params: Vec<ast::GenericParam>, span: Span) -> Generics {
Generics {
params,
where_clause: ast::WhereClause {

2
src/libsyntax_ext/deriving/mod.rs
View file

@ -136,7 +136,7 @@ fn hygienic_type_parameter(item: &Annotatable, base: &str) -> String {
ast::ItemKind::Enum(_, ast::Generics { ref params, .. }) => {
for param in params {
match param.kind {
ast::GenericParamKindAST::Type { .. } => {
ast::GenericParamKind::Type { .. } => {
typaram.push_str(&param.ident.as_str());
}
_ => {}

4
src/libsyntax_ext/env.rs
View file

@ -13,7 +13,7 @@
// interface.
//
use syntax::ast::{self, Ident, GenericArgAST};
use syntax::ast::{self, Ident, GenericArg};
use syntax::ext::base::*;
use syntax::ext::base;
use syntax::ext::build::AstBuilder;
@ -39,7 +39,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt,
cx.expr_path(cx.path_all(sp,
true,
cx.std_path(&["option", "Option", "None"]),
vec![GenericArgAST::Type(cx.ty_rptr(sp,
vec![GenericArg::Type(cx.ty_rptr(sp,
cx.ty_ident(sp, Ident::from_str("str")),
Some(lt),
ast::Mutability::Immutable))],