Rename *Parameter to *Param

src/librustc/hir/lowering.rs

@@ -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,
+    fn lower_path_param(&mut self,
-                   p: &GenericAngleBracketedParam,
+                        p: &AngleBracketedParam,
-                   itctx: ImplTraitContext)
+                        itctx: ImplTraitContext)
-                   -> GenericPathParam {
+                        -> PathParam {
         match p {
-            GenericAngleBracketedParam::Lifetime(lt) => {
+            AngleBracketedParam::Lifetime(lt) => {
-                GenericPathParam::Lifetime(self.lower_lifetime(&lt))
+                PathParam::Lifetime(self.lower_lifetime(&lt))
             }
-            GenericAngleBracketedParam::Type(ty) => {
+            AngleBracketedParam::Type(ty) => {
-                GenericPathParam::Type(self.lower_ty(&ty, itctx))
+                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,

src/librustc/hir/mod.rs

@@ -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

src/librustc/hir/print.rs

@@ -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 {

src/librustc/ich/impls_hir.rs

@@ -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)
 });

src/librustc/ty/mod.rs

@@ -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,
+            GenericParam::Lifetime(lt) => lt.index,
-            GenericParameterDef::Type(ty)     => ty.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,

src/librustc_typeck/astconv.rs

@@ -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,

src/librustc_typeck/collect.rs

@@ -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 parent_params = ty::KindIndexed { lt: parent_regions, ty: parent_types };
-    let lifetimes: Vec<ty::GenericParameterDef> =
+    let lifetimes: Vec<ty::GenericParam> =
-        regions.into_iter().map(|lt| ty::GenericParameterDef::Lifetime(lt)).collect();
+        regions.into_iter().map(|lt| ty::GenericParam::Lifetime(lt)).collect();
-    let types: Vec<ty::GenericParameterDef> =
+    let types: Vec<ty::GenericParam> =
-        types.into_iter().map(|ty| ty::GenericParameterDef::Type(ty)).collect();
+        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 {

src/librustdoc/clean/mod.rs

@@ -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),
             }
         }

src/libsyntax/ast.rs

@@ -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

src/libsyntax/ext/build.rs

@@ -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()))
     }
 

src/libsyntax/fold.rs

@@ -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) => {
+        AngleBracketedParam::Lifetime(lt) => {
-            GenericAngleBracketedParam::Lifetime(noop_fold_lifetime(lt, fld))
+            AngleBracketedParam::Lifetime(noop_fold_lifetime(lt, fld))
         }
-        GenericAngleBracketedParam::Type(ty) => {
+        AngleBracketedParam::Type(ty) => {
-            GenericAngleBracketedParam::Type(noop_fold_ty(ty, fld))
+            AngleBracketedParam::Type(noop_fold_ty(ty, fld))
         }
     }
 }

src/libsyntax/parse/parser.rs

@@ -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

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, 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),
+            AngleBracketedParam::Lifetime(lt) => self.print_lifetime(lt),
-            GenericAngleBracketedParam::Type(ty) => self.print_type(ty),
+            AngleBracketedParam::Type(ty) => self.print_type(ty),
         }
     }
 

src/libsyntax_ext/deriving/clone.rs

@@ -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) {

src/libsyntax_ext/deriving/cmp/eq.rs

@@ -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) {

src/libsyntax_ext/deriving/generic/mod.rs

@@ -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`.

src/libsyntax_ext/deriving/generic/ty.rs

@@ -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))
+                       .map(|lt| AngleBracketedParam::Lifetime(lt))
-                       .chain(tys.into_iter().map(|ty| GenericAngleBracketedParam::Type(ty)))
+                       .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,

src/libsyntax_ext/env.rs

@@ -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)],