bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rename *Parameter to *Param

Browse source
This commit is contained in:
varkor 2018-02-12 21:44:05 +00:00
parent 494859e8dd
commit 1ed60a9173
18 changed files with 81 additions and 77 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -46,7 +46,7 @@ use hir::HirVec;
use hir::map::{DefKey, DefPathData, Definitions};
use hir::def_id::{DefId, DefIndex, DefIndexAddressSpace, CRATE_DEF_INDEX};
use hir::def::{Def, PathResolution, PerNS};
use hir::GenericPathParam;
use hir::PathParam;
use lint::builtin::{self, PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES};
use middle::cstore::CrateStore;
use rustc_data_structures::indexed_vec::IndexVec;
@ -1038,16 +1038,16 @@ impl<'a> LoweringContext<'a> {
}
}
fn lower_param(&mut self,
p: &GenericAngleBracketedParam,
fn lower_path_param(&mut self,
p: &AngleBracketedParam,
itctx: ImplTraitContext)
-> GenericPathParam {
-> PathParam {
match p {
GenericAngleBracketedParam::Lifetime(lt) => {
GenericPathParam::Lifetime(self.lower_lifetime(&lt))
AngleBracketedParam::Lifetime(lt) => {
PathParam::Lifetime(self.lower_lifetime(&lt))
}
GenericAngleBracketedParam::Type(ty) => {
GenericPathParam::Type(self.lower_ty(&ty, itctx))
AngleBracketedParam::Type(ty) => {
PathParam::Type(self.lower_ty(&ty, itctx))
}
}
}
@ -1715,7 +1715,7 @@ impl<'a> LoweringContext<'a> {
if !parameters.parenthesized && parameters.lifetimes.is_empty() {
path_params.parameters = (0..expected_lifetimes).map(|_| {
GenericPathParam::Lifetime(self.elided_lifetime(path_span))
PathParam::Lifetime(self.elided_lifetime(path_span))
}).chain(path_params.parameters.into_iter()).collect();
}
@ -1734,7 +1734,7 @@ impl<'a> LoweringContext<'a> {
) -> (hir::PathParameters, bool) {
let &AngleBracketedParameterData { ref parameters, ref bindings, .. } = data;
(hir::PathParameters {
parameters: parameters.iter().map(|p| self.lower_param(p, itctx)).collect(),
parameters: parameters.iter().map(|p| self.lower_path_param(p, itctx)).collect(),
bindings: bindings.iter().map(|b| self.lower_ty_binding(b, itctx)).collect(),
parenthesized: false,
},
@ -1775,7 +1775,7 @@ impl<'a> LoweringContext<'a> {
(
hir::PathParameters {
parameters: hir_vec![GenericPathParam::Type(mk_tup(this, inputs, span))],
parameters: hir_vec![PathParam::Type(mk_tup(this, inputs, span))],
bindings: hir_vec![
hir::TypeBinding {
id: this.next_id().node_id,

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

@ -373,7 +373,7 @@ impl PathSegment {
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum GenericPathParam {
pub enum PathParam {
Lifetime(Lifetime),
Type(P<Ty>),
}
@ -381,7 +381,7 @@ pub enum GenericPathParam {
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct PathParameters {
/// The generic parameters for this path segment.
pub parameters: HirVec<GenericPathParam>,
pub parameters: HirVec<PathParam>,
/// Bindings (equality constraints) on associated types, if present.
/// E.g., `Foo<A=Bar>`.
pub bindings: HirVec<TypeBinding>,
@ -417,7 +417,7 @@ impl PathParameters {
pub fn lifetimes(&self) -> Vec<&Lifetime> {
self.parameters.iter().filter_map(|p| {
if let GenericPathParam::Lifetime(lt) = p {
if let PathParam::Lifetime(lt) = p {
Some(lt)
} else {
None
@ -427,7 +427,7 @@ impl PathParameters {
pub fn types(&self) -> Vec<&P<Ty>> {
self.parameters.iter().filter_map(|p| {
if let GenericPathParam::Type(ty) = p {
if let PathParam::Type(ty) = p {
Some(ty)
} else {
None

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

@ -25,7 +25,7 @@ use syntax_pos::{self, BytePos, FileName};
use hir;
use hir::{PatKind, RegionTyParamBound, TraitTyParamBound, TraitBoundModifier, RangeEnd};
use hir::GenericPathParam;
use hir::PathParam;
use std::cell::Cell;
use std::io::{self, Write, Read};
@ -1732,7 +1732,7 @@ impl<'a> State<'a> {
};
let elide_lifetimes = path_params.parameters.iter().all(|p| {
if let GenericPathParam::Lifetime(lt) = p {
if let PathParam::Lifetime(lt) = p {
if !lt.is_elided() {
return false;
}
@ -1742,17 +1742,21 @@ impl<'a> State<'a> {
self.commasep(Inconsistent, &path_params.parameters, |s, p| {
match p {
GenericPathParam::Lifetime(lt) => {
PathParam::Lifetime(lt) => {
if !elide_lifetimes {
s.print_lifetime(lt)
} else {
Ok(())
}
}
GenericPathParam::Type(ty) => s.print_type(ty),
PathParam::Type(ty) => s.print_type(ty),
}
})?;
if !path_params.parameters.is_empty() {
empty.set(false);
}
// FIXME(eddyb) This would leak into error messages, e.g.:
// "non-exhaustive patterns: `Some::<..>(_)` not covered".
if infer_types && false {

2
src/librustc/ich/impls_hir.rs
View file

@ -180,7 +180,7 @@ impl_stable_hash_for!(struct hir::PathSegment {
parameters
});
impl_stable_hash_for!(enum hir::GenericPathParam {
impl_stable_hash_for!(enum hir::PathParam {
Lifetime(lt),
Type(ty)
});

16
src/librustc/ty/mod.rs
View file

@ -886,16 +886,16 @@ pub struct GenericParamCount {
}
#[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
pub enum GenericParameterDef {
pub enum GenericParam {
Lifetime(RegionParameterDef),
Type(TypeParameterDef),
}
impl GenericParameterDef {
impl GenericParam {
pub fn index(&self) -> u32 {
match self {
GenericParameterDef::Lifetime(lt) => lt.index,
GenericParameterDef::Type(ty) => ty.index,
GenericParam::Lifetime(lt) => lt.index,
GenericParam::Type(ty) => ty.index,
}
}
}
@ -1011,7 +1011,7 @@ impl<'a, 'gcx, 'tcx> Generics {
pub fn lifetimes(&self) -> Vec<&RegionParameterDef> {
self.parameters.iter().filter_map(|p| {
if let GenericParameterDef::Lifetime(lt) = p {
if let GenericParam::Lifetime(lt) = p {
Some(lt)
} else {
None
@ -1021,7 +1021,7 @@ impl<'a, 'gcx, 'tcx> Generics {
pub fn types(&self) -> Vec<&TypeParameterDef> {
self.parameters.iter().filter_map(|p| {
if let GenericParameterDef::Type(ty) = p {
if let GenericParam::Type(ty) = p {
Some(ty)
} else {
None
@ -1030,11 +1030,11 @@ impl<'a, 'gcx, 'tcx> Generics {
}
pub fn parent_lifetimes(&self) -> u32 {
*self.parent_parameters.get(KindIndex::Lifetime)
*self.parent_params.get(KindIndex::Lifetime)
}
pub fn parent_types(&self) -> u32 {
*self.parent_parameters.get(KindIndex::Type)
*self.parent_params.get(KindIndex::Type)
}
pub fn region_param(&'tcx self,

4
src/librustc_typeck/astconv.rs
View file

@ -973,13 +973,13 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
segment.with_parameters(|params| {
for p in &params.parameters {
let (mut span_err, span, kind) = match p {
hir::GenericPathParam::Lifetime(lt) => {
hir::PathParam::Lifetime(lt) => {
(struct_span_err!(self.tcx().sess, lt.span, E0110,
"lifetime parameters are not allowed on this type"),
lt.span,
"lifetime")
}
hir::GenericPathParam::Type(ty) => {
hir::PathParam::Type(ty) => {
(struct_span_err!(self.tcx().sess, ty.span, E0109,
"type parameters are not allowed on this type"),
ty.span,

10
src/librustc_typeck/collect.rs
View file

@ -973,11 +973,11 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
.map(|param| (param.def_id, param.index))
.collect();
let parent_parameters = ty::KindIndexed { lt: parent_regions, ty: parent_types };
let lifetimes: Vec<ty::GenericParameterDef> =
regions.into_iter().map(|lt| ty::GenericParameterDef::Lifetime(lt)).collect();
let types: Vec<ty::GenericParameterDef> =
types.into_iter().map(|ty| ty::GenericParameterDef::Type(ty)).collect();
let parent_params = ty::KindIndexed { lt: parent_regions, ty: parent_types };
let lifetimes: Vec<ty::GenericParam> =
regions.into_iter().map(|lt| ty::GenericParam::Lifetime(lt)).collect();
let types: Vec<ty::GenericParam> =
types.into_iter().map(|ty| ty::GenericParam::Type(ty)).collect();
let parameters = lifetimes.into_iter().chain(types.into_iter()).collect();
tcx.alloc_generics(ty::Generics {

6
src/librustdoc/clean/mod.rs
View file

@ -3494,12 +3494,12 @@ impl Clean<PathParameters> for hir::PathParameters {
}
} else {
PathParameters::AngleBracketed {
lifetimes: if self.lifetimes.iter().all(|lt| lt.is_elided()) {
lifetimes: if self.lifetimes().iter().all(|lt| lt.is_elided()) {
vec![]
} else {
self.lifetimes.clean(cx)
self.lifetimes().iter().map(|lp| lp.clean(cx)).collect()
},
types: self.types.clean(cx),
types: self.types().iter().map(|tp| tp.clean(cx)).collect(),
bindings: self.bindings.clean(cx),
}
}

8
src/libsyntax/ast.rs
View file

@ -168,7 +168,7 @@ impl PathParameters {
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum GenericAngleBracketedParam {
pub enum AngleBracketedParam {
Lifetime(Lifetime),
Type(P<Ty>),
}
@ -179,7 +179,7 @@ pub struct AngleBracketedParameterData {
/// Overall span
pub span: Span,
/// The parameters for this path segment.
pub parameters: Vec<GenericAngleBracketedParam>,
pub parameters: Vec<AngleBracketedParam>,
/// Bindings (equality constraints) on associated types, if present.
///
/// E.g., `Foo<A=Bar>`.
@ -189,7 +189,7 @@ pub struct AngleBracketedParameterData {
impl AngleBracketedParameterData {
pub fn lifetimes(&self) -> Vec<&Lifetime> {
self.parameters.iter().filter_map(|p| {
if let GenericAngleBracketedParam::Lifetime(lt) = p {
if let AngleBracketedParam::Lifetime(lt) = p {
Some(lt)
} else {
None
@ -199,7 +199,7 @@ impl AngleBracketedParameterData {
pub fn types(&self) -> Vec<&P<Ty>> {
self.parameters.iter().filter_map(|p| {
if let GenericAngleBracketedParam::Type(ty) = p {
if let AngleBracketedParam::Type(ty) = p {
Some(ty)
} else {
None

10
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>,
parameters: Vec<ast::GenericAngleBracketedParam>,
parameters: Vec<ast::AngleBracketedParam>,
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,
parameters: Vec<ast::GenericAngleBracketedParam>,
parameters: Vec<ast::AngleBracketedParam>,
bindings: Vec<ast::TypeBinding>)
-> (ast::QSelf, ast::Path);
@ -314,7 +314,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
span: Span,
global: bool,
mut idents: Vec<ast::Ident> ,
parameters: Vec<ast::GenericAngleBracketedParam>,
parameters: Vec<ast::AngleBracketedParam>,
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,
parameters: Vec<ast::GenericAngleBracketedParam>,
parameters: Vec<ast::AngleBracketedParam>,
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::GenericAngleBracketedParam::Type(ty) ],
vec![ ast::AngleBracketedParam::Type(ty) ],
Vec::new()))
}

14
src/libsyntax/fold.rs
View file

@ -132,7 +132,7 @@ pub trait Folder : Sized {
noop_fold_exprs(es, self)
}
fn fold_param(&mut self, p: GenericAngleBracketedParam) -> GenericAngleBracketedParam {
fn fold_param(&mut self, p: AngleBracketedParam) -> AngleBracketedParam {
noop_fold_param(p, self)
}
@ -357,15 +357,15 @@ pub fn noop_fold_ty_binding<T: Folder>(b: TypeBinding, fld: &mut T) -> TypeBindi
}
}
pub fn noop_fold_param<T: Folder>(p: GenericAngleBracketedParam,
pub fn noop_fold_param<T: Folder>(p: AngleBracketedParam,
fld: &mut T)
-> GenericAngleBracketedParam {
-> AngleBracketedParam {
match p {
GenericAngleBracketedParam::Lifetime(lt) => {
GenericAngleBracketedParam::Lifetime(noop_fold_lifetime(lt, fld))
AngleBracketedParam::Lifetime(lt) => {
AngleBracketedParam::Lifetime(noop_fold_lifetime(lt, fld))
}
GenericAngleBracketedParam::Type(ty) => {
GenericAngleBracketedParam::Type(noop_fold_ty(ty, fld))
AngleBracketedParam::Type(ty) => {
AngleBracketedParam::Type(noop_fold_ty(ty, fld))
}
}
}

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

@ -22,7 +22,7 @@ use ast::{Expr, ExprKind, RangeLimits};
use ast::{Field, FnDecl};
use ast::{ForeignItem, ForeignItemKind, FunctionRetTy};
use ast::GenericParam;
use ast::GenericAngleBracketedParam;
use ast::AngleBracketedParam;
use ast::{Ident, ImplItem, IsAuto, Item, ItemKind};
use ast::{Label, Lifetime, LifetimeDef, Lit, LitKind};
use ast::Local;
@ -4938,7 +4938,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<GenericAngleBracketedParam>, Vec<TypeBinding>)> {
-> PResult<'a, (Vec<AngleBracketedParam>, Vec<TypeBinding>)> {
let mut parameters = Vec::new();
let mut bindings = Vec::new();
let mut seen_type = false;
@ -4946,7 +4946,7 @@ impl<'a> Parser<'a> {
loop {
if self.check_lifetime() && self.look_ahead(1, |t| !t.is_like_plus()) {
// Parse lifetime argument.
parameters.push(GenericAngleBracketedParam::Lifetime(self.expect_lifetime()));
parameters.push(AngleBracketedParam::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(GenericAngleBracketedParam::Type(ty_param));
parameters.push(AngleBracketedParam::Type(ty_param));
seen_type = true;
} else {
break

8
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, GenericAngleBracketedParam};
use ast::{Attribute, MacDelimiter, AngleBracketedParam};
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: &GenericAngleBracketedParam) -> io::Result<()> {
pub fn print_param(&mut self, param: &AngleBracketedParam) -> io::Result<()> {
match param {
GenericAngleBracketedParam::Lifetime(lt) => self.print_lifetime(lt),
GenericAngleBracketedParam::Type(ty) => self.print_type(ty),
AngleBracketedParam::Lifetime(lt) => self.print_lifetime(lt),
AngleBracketedParam::Type(ty) => self.print_type(ty),
}
}

4
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::GenericAngleBracketedParam;
use syntax::ast::AngleBracketedParam;
use syntax::attr;
use syntax::ext::base::{Annotatable, ExtCtxt};
use syntax::ext::build::AstBuilder;
@ -124,7 +124,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![GenericAngleBracketedParam::Type(ty)], vec![]);
vec![AngleBracketedParam::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, GenericAngleBracketedParam};
use syntax::ast::{self, Expr, MetaItem, AngleBracketedParam};
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![GenericAngleBracketedParam::Type(ty)], vec![]);
vec![AngleBracketedParam::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) {

6
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, GenericParam, Generics, Ident, PatKind};
use syntax::ast::{VariantData, GenericAngleBracketedParam};
use syntax::ast::{VariantData, AngleBracketedParam};
use syntax::attr;
use syntax::ext::base::{Annotatable, ExtCtxt};
use syntax::ext::build::AstBuilder;
@ -683,9 +683,9 @@ impl<'a> TraitDef<'a> {
.collect();
let self_params = self_lifetimes.into_iter()
.map(|lt| GenericAngleBracketedParam::Lifetime(lt))
.map(|lt| AngleBracketedParam::Lifetime(lt))
.chain(self_ty_params.into_iter().map(|ty|
GenericAngleBracketedParam::Type(ty)))
AngleBracketedParam::Type(ty)))
.collect();
// Create the type of `self`.

10
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, GenericParam, Generics, Ident, SelfKind, GenericAngleBracketedParam};
use syntax::ast::{Expr, GenericParam, Generics, Ident, SelfKind, AngleBracketedParam};
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| GenericAngleBracketedParam::Lifetime(lt))
.chain(tys.into_iter().map(|ty| GenericAngleBracketedParam::Type(ty)))
.map(|lt| AngleBracketedParam::Lifetime(lt))
.chain(tys.into_iter().map(|ty| AngleBracketedParam::Type(ty)))
.collect();
match self.kind {
@ -206,9 +206,9 @@ impl<'a> Ty<'a> {
.collect();
let params = lifetimes.into_iter()
.map(|lt| GenericAngleBracketedParam::Lifetime(lt))
.map(|lt| AngleBracketedParam::Lifetime(lt))
.chain(ty_params.into_iter().map(|ty|
GenericAngleBracketedParam::Type(ty)))
AngleBracketedParam::Type(ty)))
.collect();
cx.path_all(span,

4
src/libsyntax_ext/env.rs
View file

@ -13,7 +13,7 @@
// interface.
//
use syntax::ast::{self, Ident, GenericAngleBracketedParam};
use syntax::ast::{self, Ident, AngleBracketedParam};
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![GenericAngleBracketedParam::Type(cx.ty_rptr(sp,
vec![AngleBracketedParam::Type(cx.ty_rptr(sp,
cx.ty_ident(sp, Ident::from_str("str")),
Some(lt),
ast::Mutability::Immutable)],