From 76c0d687453cb1da2e76a1c8e007ac080f8aa0d7 Mon Sep 17 00:00:00 2001 From: varkor Date: Fri, 23 Feb 2018 17:48:54 +0000 Subject: Rename "parameter" to "arg" --- src/libsyntax/ast.rs | 34 +++++++++++++++++----------------- src/libsyntax/ext/build.rs | 22 +++++++++++----------- src/libsyntax/fold.rs | 38 +++++++++++++++++++------------------- src/libsyntax/parse/parser.rs | 30 +++++++++++++++--------------- src/libsyntax/print/pprust.rs | 28 ++++++++++++++-------------- src/libsyntax/visit.rs | 12 ++++++------ 6 files changed, 82 insertions(+), 82 deletions(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 7bcaf9bbd52..7ff00123624 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -135,27 +135,27 @@ pub struct PathSegment { /// `Some` means that parameter list is supplied (`Path`) /// but it can be empty (`Path<>`). /// `P` is used as a size optimization for the common case with no parameters. - pub parameters: Option>, + pub args: Option>, } impl PathSegment { pub fn from_ident(ident: Ident) -> Self { - PathSegment { ident, parameters: None } + PathSegment { ident, args: None } } pub fn crate_root(span: Span) -> Self { PathSegment::from_ident(Ident::new(keywords::CrateRoot.name(), span)) } } -/// Parameters of a path segment. +/// Arguments of a path segment. /// /// E.g. `` as in `Foo` or `(A, B)` as in `Foo(A, B)` #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum GenericArgs { /// The `<'a, A,B,C>` in `foo::bar::baz::<'a, A,B,C>` - AngleBracketed(AngleBracketedParameterData), + AngleBracketed(AngleBracketedArgs), /// The `(A,B)` and `C` in `Foo(A,B) -> C` - Parenthesized(ParenthesizedParameterData), + Parenthesized(ParenthesizedArgData), } impl GenericArgs { @@ -168,28 +168,28 @@ impl GenericArgs { } #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub enum AngleBracketedParam { +pub enum GenericArg { Lifetime(Lifetime), Type(P), } /// A path like `Foo<'a, T>` #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Default)] -pub struct AngleBracketedParameterData { +pub struct AngleBracketedArgs { /// Overall span pub span: Span, - /// The parameters for this path segment. - pub parameters: Vec, + /// The arguments for this path segment. + pub args: Vec, /// Bindings (equality constraints) on associated types, if present. /// /// E.g., `Foo`. pub bindings: Vec, } -impl AngleBracketedParameterData { +impl AngleBracketedArgs { pub fn lifetimes(&self) -> impl DoubleEndedIterator { - self.parameters.iter().filter_map(|p| { - if let AngleBracketedParam::Lifetime(lt) = p { + self.args.iter().filter_map(|p| { + if let GenericArg::Lifetime(lt) = p { Some(lt) } else { None @@ -198,8 +198,8 @@ impl AngleBracketedParameterData { } pub fn types(&self) -> impl DoubleEndedIterator> { - self.parameters.iter().filter_map(|p| { - if let AngleBracketedParam::Type(ty) = p { + self.args.iter().filter_map(|p| { + if let GenericArg::Type(ty) = p { Some(ty) } else { None @@ -208,13 +208,13 @@ impl AngleBracketedParameterData { } } -impl Into>> for AngleBracketedParameterData { +impl Into>> for AngleBracketedArgs { fn into(self) -> Option> { Some(P(GenericArgs::AngleBracketed(self))) } } -impl Into>> for ParenthesizedParameterData { +impl Into>> for ParenthesizedArgData { fn into(self) -> Option> { Some(P(GenericArgs::Parenthesized(self))) } @@ -222,7 +222,7 @@ impl Into>> for ParenthesizedParameterData { /// A path like `Foo(A,B) -> C` #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub struct ParenthesizedParameterData { +pub struct ParenthesizedArgData { /// Overall span pub span: Span, diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index a59e34580c0..05a345fb2a1 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -31,7 +31,7 @@ pub trait AstBuilder { fn path_all(&self, sp: Span, global: bool, idents: Vec, - parameters: Vec, + parameters: Vec, bindings: Vec) -> ast::Path; @@ -42,7 +42,7 @@ pub trait AstBuilder { fn qpath_all(&self, self_type: P, trait_path: ast::Path, ident: ast::Ident, - parameters: Vec, + parameters: Vec, bindings: Vec) -> (ast::QSelf, ast::Path); @@ -314,7 +314,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> { span: Span, global: bool, mut idents: Vec , - parameters: Vec, + args: Vec, bindings: Vec ) -> ast::Path { let last_ident = idents.pop().unwrap(); @@ -323,12 +323,12 @@ impl<'a> AstBuilder for ExtCtxt<'a> { segments.extend(idents.into_iter().map(|ident| { ast::PathSegment::from_ident(ident.with_span_pos(span)) })); - let parameters = if !parameters.is_empty() !bindings.is_empty() { - ast::AngleBracketedParameterData { parameters, bindings, span }.into() + let args = if !args.is_empty() || !bindings.is_empty() { + ast::AngleBracketedArgs { args, bindings, span }.into() } else { None }; - segments.push(ast::PathSegment { ident: last_ident.with_span_pos(span), parameters }); + segments.push(ast::PathSegment { ident: last_ident.with_span_pos(span), args }); let mut path = ast::Path { span, segments }; if global { if let Some(seg) = path.make_root() { @@ -356,16 +356,16 @@ impl<'a> AstBuilder for ExtCtxt<'a> { self_type: P, trait_path: ast::Path, ident: ast::Ident, - parameters: Vec, + args: Vec, bindings: Vec) -> (ast::QSelf, ast::Path) { let mut path = trait_path; - let parameters = if !parameters.is_empty() || !bindings.is_empty() { - ast::AngleBracketedParameterData { parameters, bindings, span: ident.span }.into() + let args = if !args.is_empty() || !bindings.is_empty() { + ast::AngleBracketedArgs { args, bindings, span: ident.span }.into() } else { None }; - path.segments.push(ast::PathSegment { ident, parameters }); + path.segments.push(ast::PathSegment { ident, args }); (ast::QSelf { ty: self_type, @@ -424,7 +424,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> { self.path_all(DUMMY_SP, true, self.std_path(&["option", "Option"]), - vec![ ast::AngleBracketedParam::Type(ty) ], + vec![ ast::GenericArg::Type(ty) ], Vec::new())) } diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index decb7e56132..dc23ed19d1b 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -132,11 +132,11 @@ pub trait Folder : Sized { noop_fold_exprs(es, self) } - fn fold_param(&mut self, p: AngleBracketedParam) -> AngleBracketedParam { + fn fold_param(&mut self, p: GenericArg) -> GenericArg { match p { - AngleBracketedParam::Lifetime(lt) => - AngleBracketedParam::Lifetime(self.fold_lifetime(lt)), - AngleBracketedParam::Type(ty) => AngleBracketedParam::Type(self.fold_ty(ty)), + GenericArg::Lifetime(lt) => + GenericArg::Lifetime(self.fold_lifetime(lt)), + GenericArg::Type(ty) => GenericArg::Type(self.fold_ty(ty)), } } @@ -184,14 +184,14 @@ pub trait Folder : Sized { noop_fold_generic_args(p, self) } - fn fold_angle_bracketed_parameter_data(&mut self, p: AngleBracketedParameterData) - -> AngleBracketedParameterData + fn fold_angle_bracketed_parameter_data(&mut self, p: AngleBracketedArgs) + -> AngleBracketedArgs { noop_fold_angle_bracketed_parameter_data(p, self) } - fn fold_parenthesized_parameter_data(&mut self, p: ParenthesizedParameterData) - -> ParenthesizedParameterData + fn fold_parenthesized_parameter_data(&mut self, p: ParenthesizedArgData) + -> ParenthesizedArgData { noop_fold_parenthesized_parameter_data(p, self) } @@ -441,9 +441,9 @@ pub fn noop_fold_usize(i: usize, _: &mut T) -> usize { pub fn noop_fold_path(Path { segments, span }: Path, fld: &mut T) -> Path { Path { - segments: segments.move_map(|PathSegment {ident, parameters}| PathSegment { + segments: segments.move_map(|PathSegment {ident, args}| PathSegment { ident: fld.fold_ident(ident), - parameters: parameters.map(|ps| ps.map(|ps| fld.fold_generic_args(ps))), + args: args.map(|ps| ps.map(|ps| fld.fold_generic_args(ps))), }), span: fld.new_span(span) } @@ -473,22 +473,22 @@ pub fn noop_fold_generic_args(generic_args: GenericArgs, fld: &mut T) } } -pub fn noop_fold_angle_bracketed_parameter_data(data: AngleBracketedParameterData, +pub fn noop_fold_angle_bracketed_parameter_data(data: AngleBracketedArgs, fld: &mut T) - -> AngleBracketedParameterData + -> AngleBracketedArgs { - let AngleBracketedParameterData { parameters, bindings, span } = data; - AngleBracketedParameterData { parameters: parameters.move_map(|p| fld.fold_param(p)), + let AngleBracketedArgs { args, bindings, span } = data; + AngleBracketedArgs { args: args.move_map(|p| fld.fold_param(p)), bindings: bindings.move_map(|b| fld.fold_ty_binding(b)), span: fld.new_span(span) } } -pub fn noop_fold_parenthesized_parameter_data(data: ParenthesizedParameterData, +pub fn noop_fold_parenthesized_parameter_data(data: ParenthesizedArgData, fld: &mut T) - -> ParenthesizedParameterData + -> ParenthesizedArgData { - let ParenthesizedParameterData { inputs, output, span } = data; - ParenthesizedParameterData { inputs: inputs.move_map(|ty| fld.fold_ty(ty)), + let ParenthesizedArgData { inputs, output, span } = data; + ParenthesizedArgData { inputs: inputs.move_map(|ty| fld.fold_ty(ty)), output: output.map(|ty| fld.fold_ty(ty)), span: fld.new_span(span) } } @@ -1191,7 +1191,7 @@ pub fn noop_fold_expr(Expr {id, node, span, attrs}: Expr, folder: &mu ExprKind::MethodCall( PathSegment { ident: folder.fold_ident(seg.ident), - parameters: seg.parameters.map(|ps| { + args: seg.args.map(|ps| { ps.map(|ps| folder.fold_generic_args(ps)) }), }, diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index e54c5445fa2..a51b3bc0ae4 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -9,7 +9,7 @@ // except according to those terms. use rustc_target::spec::abi::{self, Abi}; -use ast::{AngleBracketedParameterData, ParenthesizedParameterData, AttrStyle, BareFnTy}; +use ast::{AngleBracketedArgs, ParenthesizedArgData, AttrStyle, BareFnTy}; use ast::{RegionTyParamBound, TraitTyParamBound, TraitBoundModifier}; use ast::Unsafety; use ast::{Mod, AnonConst, Arg, Arm, Attribute, BindingMode, TraitItemKind}; @@ -22,7 +22,7 @@ use ast::{Expr, ExprKind, RangeLimits}; use ast::{Field, FnDecl}; use ast::{ForeignItem, ForeignItemKind, FunctionRetTy}; use ast::GenericParam; -use ast::AngleBracketedParam; +use ast::GenericArg; use ast::{Ident, ImplItem, IsAuto, Item, ItemKind}; use ast::{Label, Lifetime, LifetimeDef, Lit, LitKind}; use ast::Local; @@ -1895,7 +1895,7 @@ impl<'a> Parser<'a> { -> PResult<'a, ast::Path> { maybe_whole!(self, NtPath, |path| { if style == PathStyle::Mod && - path.segments.iter().any(|segment| segment.parameters.is_some()) { + path.segments.iter().any(|segment| segment.args.is_some()) { self.diagnostic().span_err(path.span, "unexpected generic arguments in path"); } path @@ -1970,12 +1970,12 @@ impl<'a> Parser<'a> { .span_label(self.prev_span, "try removing `::`").emit(); } - let parameters = if self.eat_lt() { + let args = if self.eat_lt() { // `<'a, T, A = U>` - let (parameters, bindings) = self.parse_generic_args()?; + let (args, bindings) = self.parse_generic_args()?; self.expect_gt()?; let span = lo.to(self.prev_span); - AngleBracketedParameterData { parameters, bindings, span }.into() + AngleBracketedArgs { args, bindings, span }.into() } else { // `(T, U) -> R` self.bump(); // `(` @@ -1991,10 +1991,10 @@ impl<'a> Parser<'a> { None }; let span = lo.to(self.prev_span); - ParenthesizedParameterData { inputs, output, span }.into() + ParenthesizedArgData { inputs, output, span }.into() }; - PathSegment { ident, parameters } + PathSegment { ident, args } } else { // Generic arguments are not found. PathSegment::from_ident(ident) @@ -2544,8 +2544,8 @@ impl<'a> Parser<'a> { } _ => { // Field access `expr.f` - if let Some(parameters) = segment.parameters { - self.span_err(parameters.span(), + if let Some(args) = segment.args { + self.span_err(args.span(), "field expressions may not have generic arguments"); } @@ -4938,15 +4938,15 @@ 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, Vec)> { - let mut parameters = Vec::new(); + -> PResult<'a, (Vec, Vec)> { + let mut args = Vec::new(); let mut bindings = Vec::new(); let mut seen_type = false; let mut seen_binding = false; loop { if self.check_lifetime() && self.look_ahead(1, |t| !t.is_like_plus()) { // Parse lifetime argument. - parameters.push(AngleBracketedParam::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"); @@ -4971,7 +4971,7 @@ impl<'a> Parser<'a> { self.span_err(ty_param.span, "type parameters must be declared prior to associated type bindings"); } - parameters.push(AngleBracketedParam::Type(ty_param)); + args.push(GenericArg::Type(ty_param)); seen_type = true; } else { break @@ -4981,7 +4981,7 @@ impl<'a> Parser<'a> { break } } - Ok((parameters, bindings)) + Ok((args, bindings)) } /// Parses an optional `where` clause and places it in `generics`. diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 287fe0b636f..3b487430c52 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -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, AngleBracketedParam}; +use ast::{Attribute, MacDelimiter, GenericArg}; use util::parser::{self, AssocOp, Fixity}; use attr; use codemap::{self, CodeMap}; @@ -1017,10 +1017,10 @@ impl<'a> State<'a> { Ok(()) } - pub fn print_param(&mut self, param: &AngleBracketedParam) -> io::Result<()> { + pub fn print_param(&mut self, param: &GenericArg) -> io::Result<()> { match param { - AngleBracketedParam::Lifetime(lt) => self.print_lifetime(lt), - AngleBracketedParam::Type(ty) => self.print_type(ty), + GenericArg::Lifetime(lt) => self.print_lifetime(lt), + GenericArg::Type(ty) => self.print_type(ty), } } @@ -1991,8 +1991,8 @@ impl<'a> State<'a> { self.print_expr_maybe_paren(&args[0], parser::PREC_POSTFIX)?; self.s.word(".")?; self.print_ident(segment.ident)?; - if let Some(ref parameters) = segment.parameters { - self.print_generic_args(parameters, true)?; + if let Some(ref args) = segment.args { + self.print_generic_args(args, true)?; } self.print_call_post(base_args) } @@ -2435,8 +2435,8 @@ impl<'a> State<'a> { if segment.ident.name != keywords::CrateRoot.name() && segment.ident.name != keywords::DollarCrate.name() { self.print_ident(segment.ident)?; - if let Some(ref parameters) = segment.parameters { - self.print_generic_args(parameters, colons_before_params)?; + if let Some(ref args) = segment.args { + self.print_generic_args(args, colons_before_params)?; } } else if segment.ident.name == keywords::DollarCrate.name() { self.print_dollar_crate(segment.ident.span.ctxt())?; @@ -2462,14 +2462,14 @@ impl<'a> State<'a> { self.s.word("::")?; let item_segment = path.segments.last().unwrap(); self.print_ident(item_segment.ident)?; - match item_segment.parameters { - Some(ref parameters) => self.print_generic_args(parameters, colons_before_params), + match item_segment.args { + Some(ref args) => self.print_generic_args(args, colons_before_params), None => Ok(()), } } fn print_generic_args(&mut self, - parameters: &ast::GenericArgs, + args: &ast::GenericArgs, colons_before_params: bool) -> io::Result<()> { @@ -2477,13 +2477,13 @@ impl<'a> State<'a> { self.s.word("::")? } - match *parameters { + match *args { ast::GenericArgs::AngleBracketed(ref data) => { self.s.word("<")?; - self.commasep(Inconsistent, &data.parameters, |s, p| s.print_param(p))?; + self.commasep(Inconsistent, &data.args, |s, p| s.print_param(p))?; - let mut comma = data.parameters.len() != 0; + let mut comma = data.args.len() != 0; for binding in data.bindings.iter() { if comma { diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 6dc61f3058a..906f1941cd6 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -131,10 +131,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_angle_bracketed_param(&mut self, param: &'ast AngleBracketedParam) { + fn visit_angle_bracketed_param(&mut self, param: &'ast GenericArg) { match param { - AngleBracketedParam::Lifetime(lt) => self.visit_lifetime(lt), - AngleBracketedParam::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) { @@ -381,8 +381,8 @@ pub fn walk_path_segment<'a, V: Visitor<'a>>(visitor: &mut V, path_span: Span, segment: &'a PathSegment) { visitor.visit_ident(segment.ident); - if let Some(ref parameters) = segment.parameters { - visitor.visit_generic_args(path_span, parameters); + if let Some(ref args) = segment.args { + visitor.visit_generic_args(path_span, args); } } @@ -393,7 +393,7 @@ pub fn walk_generic_args<'a, V>(visitor: &mut V, { match *generic_args { GenericArgs::AngleBracketed(ref data) => { - walk_list!(visitor, visit_angle_bracketed_param, &data.parameters); + walk_list!(visitor, visit_angle_bracketed_param, &data.args); walk_list!(visitor, visit_assoc_type_binding, &data.bindings); } GenericArgs::Parenthesized(ref data) => { -- cgit 1.4.1-3-g733a5