Auto merge of #30526 - Ms2ger:PathParameters, r=brson

bors · bors · commit 85fb3b6fc0a6 · 2015-12-30T14:19:08.000Z
diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs
@@ -319,9 +319,9 @@ pub fn lower_path_parameters(lctx: &LoweringContext,
                              path_parameters: &PathParameters)
                              -> hir::PathParameters {
     match *path_parameters {
-        AngleBracketedParameters(ref data) =>
+        PathParameters::AngleBracketed(ref data) =>
             hir::AngleBracketedParameters(lower_angle_bracketed_parameter_data(lctx, data)),
-        ParenthesizedParameters(ref data) =>
+        PathParameters::Parenthesized(ref data) =>
             hir::ParenthesizedParameters(lower_parenthesized_parameter_data(lctx, data)),
     }
 }
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
@@ -250,14 +250,14 @@ pub struct PathSegment {
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub enum PathParameters {
     /// The `<'a, A,B,C>` in `foo::bar::baz::<'a, A,B,C>`
-    AngleBracketedParameters(AngleBracketedParameterData),
+    AngleBracketed(AngleBracketedParameterData),
     /// The `(A,B)` and `C` in `Foo(A,B) -> C`
-    ParenthesizedParameters(ParenthesizedParameterData),
+    Parenthesized(ParenthesizedParameterData),
 }
 
 impl PathParameters {
     pub fn none() -> PathParameters {
-        AngleBracketedParameters(AngleBracketedParameterData {
+        PathParameters::AngleBracketed(AngleBracketedParameterData {
             lifetimes: Vec::new(),
             types: P::empty(),
             bindings: P::empty(),
@@ -266,36 +266,36 @@ impl PathParameters {
 
     pub fn is_empty(&self) -> bool {
         match *self {
-            AngleBracketedParameters(ref data) => data.is_empty(),
+            PathParameters::AngleBracketed(ref data) => data.is_empty(),
 
             // Even if the user supplied no types, something like
             // `X()` is equivalent to `X<(),()>`.
-            ParenthesizedParameters(..) => false,
+            PathParameters::Parenthesized(..) => false,
         }
     }
 
     pub fn has_lifetimes(&self) -> bool {
         match *self {
-            AngleBracketedParameters(ref data) => !data.lifetimes.is_empty(),
-            ParenthesizedParameters(_) => false,
+            PathParameters::AngleBracketed(ref data) => !data.lifetimes.is_empty(),
+            PathParameters::Parenthesized(_) => false,
         }
     }
 
     pub fn has_types(&self) -> bool {
         match *self {
-            AngleBracketedParameters(ref data) => !data.types.is_empty(),
-            ParenthesizedParameters(..) => true,
+            PathParameters::AngleBracketed(ref data) => !data.types.is_empty(),
+            PathParameters::Parenthesized(..) => true,
         }
     }
 
     /// Returns the types that the user wrote. Note that these do not necessarily map to the type
     /// parameters in the parenthesized case.
     pub fn types(&self) -> Vec<&P<Ty>> {
         match *self {
-            AngleBracketedParameters(ref data) => {
+            PathParameters::AngleBracketed(ref data) => {
                 data.types.iter().collect()
             }
-            ParenthesizedParameters(ref data) => {
+            PathParameters::Parenthesized(ref data) => {
                 data.inputs.iter()
                     .chain(data.output.iter())
                     .collect()
@@ -305,21 +305,21 @@ impl PathParameters {
 
     pub fn lifetimes(&self) -> Vec<&Lifetime> {
         match *self {
-            AngleBracketedParameters(ref data) => {
+            PathParameters::AngleBracketed(ref data) => {
                 data.lifetimes.iter().collect()
             }
-            ParenthesizedParameters(_) => {
+            PathParameters::Parenthesized(_) => {
                 Vec::new()
             }
         }
     }
 
     pub fn bindings(&self) -> Vec<&P<TypeBinding>> {
         match *self {
-            AngleBracketedParameters(ref data) => {
+            PathParameters::AngleBracketed(ref data) => {
                 data.bindings.iter().collect()
             }
-            ParenthesizedParameters(_) => {
+            PathParameters::Parenthesized(_) => {
                 Vec::new()
             }
         }
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
@@ -40,7 +40,7 @@ pub fn ident_to_path(s: Span, identifier: Ident) -> Path {
         segments: vec!(
             ast::PathSegment {
                 identifier: identifier,
-                parameters: ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
+                parameters: ast::PathParameters::AngleBracketed(ast::AngleBracketedParameterData {
                     lifetimes: Vec::new(),
                     types: P::empty(),
                     bindings: P::empty(),
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
@@ -328,7 +328,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
         }).collect();
         segments.push(ast::PathSegment {
             identifier: last_identifier,
-            parameters: ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
+            parameters: ast::PathParameters::AngleBracketed(ast::AngleBracketedParameterData {
                 lifetimes: lifetimes,
                 types: P::from_vec(types),
                 bindings: P::from_vec(bindings),
@@ -366,7 +366,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
         let mut path = trait_path;
         path.segments.push(ast::PathSegment {
             identifier: ident,
-            parameters: ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
+            parameters: ast::PathParameters::AngleBracketed(ast::AngleBracketedParameterData {
                 lifetimes: lifetimes,
                 types: P::from_vec(types),
                 bindings: P::from_vec(bindings),
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
@@ -469,10 +469,10 @@ pub fn noop_fold_path_parameters<T: Folder>(path_parameters: PathParameters, fld
                                             -> PathParameters
 {
     match path_parameters {
-        AngleBracketedParameters(data) =>
-            AngleBracketedParameters(fld.fold_angle_bracketed_parameter_data(data)),
-        ParenthesizedParameters(data) =>
-            ParenthesizedParameters(fld.fold_parenthesized_parameter_data(data)),
+        PathParameters::AngleBracketed(data) =>
+            PathParameters::AngleBracketed(fld.fold_angle_bracketed_parameter_data(data)),
+        PathParameters::Parenthesized(data) =>
+            PathParameters::Parenthesized(fld.fold_parenthesized_parameter_data(data)),
     }
 }
 
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -1697,7 +1697,7 @@ impl<'a> Parser<'a> {
             let parameters = if try!(self.eat_lt() ){
                 let (lifetimes, types, bindings) = try!(self.parse_generic_values_after_lt());
 
-                ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
+                ast::PathParameters::AngleBracketed(ast::AngleBracketedParameterData {
                     lifetimes: lifetimes,
                     types: P::from_vec(types),
                     bindings: P::from_vec(bindings),
@@ -1718,7 +1718,7 @@ impl<'a> Parser<'a> {
 
                 let hi = self.last_span.hi;
 
-                ast::ParenthesizedParameters(ast::ParenthesizedParameterData {
+                ast::PathParameters::Parenthesized(ast::ParenthesizedParameterData {
                     span: mk_sp(lo, hi),
                     inputs: inputs,
                     output: output_ty,
@@ -1759,13 +1759,14 @@ impl<'a> Parser<'a> {
             if try!(self.eat_lt() ){
                 // Consumed `a::b::<`, go look for types
                 let (lifetimes, types, bindings) = try!(self.parse_generic_values_after_lt());
+                let parameters = ast::AngleBracketedParameterData {
+                    lifetimes: lifetimes,
+                    types: P::from_vec(types),
+                    bindings: P::from_vec(bindings),
+                };
                 segments.push(ast::PathSegment {
                     identifier: identifier,
-                    parameters: ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
-                        lifetimes: lifetimes,
-                        types: P::from_vec(types),
-                        bindings: P::from_vec(bindings),
-                    }),
+                    parameters: ast::PathParameters::AngleBracketed(parameters),
                 });
 
                 // Consumed `a::b::<T,U>`, check for `::` before proceeding
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
@@ -2403,7 +2403,7 @@ impl<'a> State<'a> {
         }
 
         match *parameters {
-            ast::AngleBracketedParameters(ref data) => {
+            ast::PathParameters::AngleBracketed(ref data) => {
                 try!(word(&mut self.s, "<"));
 
                 let mut comma = false;
@@ -2440,7 +2440,7 @@ impl<'a> State<'a> {
                 try!(word(&mut self.s, ">"))
             }
 
-            ast::ParenthesizedParameters(ref data) => {
+            ast::PathParameters::Parenthesized(ref data) => {
                 try!(word(&mut self.s, "("));
                 try!(self.commasep(
                     Inconsistent,
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
@@ -399,12 +399,12 @@ pub fn walk_path_parameters<'v, V: Visitor<'v>>(visitor: &mut V,
                                                 _path_span: Span,
                                                 path_parameters: &'v PathParameters) {
     match *path_parameters {
-        AngleBracketedParameters(ref data) => {
+        PathParameters::AngleBracketed(ref data) => {
             walk_list!(visitor, visit_ty, &data.types);
             walk_list!(visitor, visit_lifetime, &data.lifetimes);
             walk_list!(visitor, visit_assoc_type_binding, &data.bindings);
         }
-        ParenthesizedParameters(ref data) => {
+        PathParameters::Parenthesized(ref data) => {
             walk_list!(visitor, visit_ty, &data.inputs);
             walk_list!(visitor, visit_ty, &data.output);
         }

Original file line number	Diff line number	Diff line change
`@@ -319,9 +319,9 @@ pub fn lower_path_parameters(lctx: &LoweringContext,`
`319`	`319`	`path_parameters: &PathParameters)`
`320`	`320`	`-> hir::PathParameters {`
`321`	`321`	`match *path_parameters {`
`322`		`- AngleBracketedParameters(ref data) =>`
	`322`	`+ PathParameters::AngleBracketed(ref data) =>`
`323`	`323`	`hir::AngleBracketedParameters(lower_angle_bracketed_parameter_data(lctx, data)),`
`324`		`- ParenthesizedParameters(ref data) =>`
	`324`	`+ PathParameters::Parenthesized(ref data) =>`
`325`	`325`	`hir::ParenthesizedParameters(lower_parenthesized_parameter_data(lctx, data)),`
`326`	`326`	`}`
`327`	`327`	`}`
Original file line number	Diff line number	Diff line change
`@@ -250,14 +250,14 @@ pub struct PathSegment {`
`250`	`250`	`#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]`
`251`	`251`	`pub enum PathParameters {`
`252`	`252`	/// The `<'a, A,B,C>` in `foo::bar::baz::<'a, A,B,C>`
`253`		`- AngleBracketedParameters(AngleBracketedParameterData),`
	`253`	`+ AngleBracketed(AngleBracketedParameterData),`
`254`	`254`	/// The `(A,B)` and `C` in `Foo(A,B) -> C`
`255`		`- ParenthesizedParameters(ParenthesizedParameterData),`
	`255`	`+ Parenthesized(ParenthesizedParameterData),`
`256`	`256`	`}`
`257`	`257`
`258`	`258`	`impl PathParameters {`
`259`	`259`	`pub fn none() -> PathParameters {`
`260`		`- AngleBracketedParameters(AngleBracketedParameterData {`
	`260`	`+ PathParameters::AngleBracketed(AngleBracketedParameterData {`
`261`	`261`	`lifetimes: Vec::new(),`
`262`	`262`	`types: P::empty(),`
`263`	`263`	`bindings: P::empty(),`
`@@ -266,36 +266,36 @@ impl PathParameters {`
`266`	`266`
`267`	`267`	`pub fn is_empty(&self) -> bool {`
`268`	`268`	`match *self {`
`269`		`- AngleBracketedParameters(ref data) => data.is_empty(),`
	`269`	`+ PathParameters::AngleBracketed(ref data) => data.is_empty(),`
`270`	`270`
`271`	`271`	`// Even if the user supplied no types, something like`
`272`	`272`	// `X()` is equivalent to `X<(),()>`.
`273`		`- ParenthesizedParameters(..) => false,`
	`273`	`+ PathParameters::Parenthesized(..) => false,`
`274`	`274`	`}`
`275`	`275`	`}`
`276`	`276`
`277`	`277`	`pub fn has_lifetimes(&self) -> bool {`
`278`	`278`	`match *self {`
`279`		`- AngleBracketedParameters(ref data) => !data.lifetimes.is_empty(),`
`280`		`- ParenthesizedParameters(_) => false,`
	`279`	`+ PathParameters::AngleBracketed(ref data) => !data.lifetimes.is_empty(),`
	`280`	`+ PathParameters::Parenthesized(_) => false,`
`281`	`281`	`}`
`282`	`282`	`}`
`283`	`283`
`284`	`284`	`pub fn has_types(&self) -> bool {`
`285`	`285`	`match *self {`
`286`		`- AngleBracketedParameters(ref data) => !data.types.is_empty(),`
`287`		`- ParenthesizedParameters(..) => true,`
	`286`	`+ PathParameters::AngleBracketed(ref data) => !data.types.is_empty(),`
	`287`	`+ PathParameters::Parenthesized(..) => true,`
`288`	`288`	`}`
`289`	`289`	`}`
`290`	`290`
`291`	`291`	`/// Returns the types that the user wrote. Note that these do not necessarily map to the type`
`292`	`292`	`/// parameters in the parenthesized case.`
`293`	`293`	`pub fn types(&self) -> Vec<&P<Ty>> {`
`294`	`294`	`match *self {`
`295`		`- AngleBracketedParameters(ref data) => {`
	`295`	`+ PathParameters::AngleBracketed(ref data) => {`
`296`	`296`	`data.types.iter().collect()`
`297`	`297`	`}`
`298`		`- ParenthesizedParameters(ref data) => {`
	`298`	`+ PathParameters::Parenthesized(ref data) => {`
`299`	`299`	`data.inputs.iter()`
`300`	`300`	`.chain(data.output.iter())`
`301`	`301`	`.collect()`
`@@ -305,21 +305,21 @@ impl PathParameters {`
`305`	`305`
`306`	`306`	`pub fn lifetimes(&self) -> Vec<&Lifetime> {`
`307`	`307`	`match *self {`
`308`		`- AngleBracketedParameters(ref data) => {`
	`308`	`+ PathParameters::AngleBracketed(ref data) => {`
`309`	`309`	`data.lifetimes.iter().collect()`
`310`	`310`	`}`
`311`		`- ParenthesizedParameters(_) => {`
	`311`	`+ PathParameters::Parenthesized(_) => {`
`312`	`312`	`Vec::new()`
`313`	`313`	`}`
`314`	`314`	`}`
`315`	`315`	`}`
`316`	`316`
`317`	`317`	`pub fn bindings(&self) -> Vec<&P<TypeBinding>> {`
`318`	`318`	`match *self {`
`319`		`- AngleBracketedParameters(ref data) => {`
	`319`	`+ PathParameters::AngleBracketed(ref data) => {`
`320`	`320`	`data.bindings.iter().collect()`
`321`	`321`	`}`
`322`		`- ParenthesizedParameters(_) => {`
	`322`	`+ PathParameters::Parenthesized(_) => {`
`323`	`323`	`Vec::new()`
`324`	`324`	`}`
`325`	`325`	`}`
Original file line number	Diff line number	Diff line change
`@@ -469,10 +469,10 @@ pub fn noop_fold_path_parameters<T: Folder>(path_parameters: PathParameters, fld`
`469`	`469`	`-> PathParameters`
`470`	`470`	`{`
`471`	`471`	`match path_parameters {`
`472`		`- AngleBracketedParameters(data) =>`
`473`		`- AngleBracketedParameters(fld.fold_angle_bracketed_parameter_data(data)),`
`474`		`- ParenthesizedParameters(data) =>`
`475`		`- ParenthesizedParameters(fld.fold_parenthesized_parameter_data(data)),`
	`472`	`+ PathParameters::AngleBracketed(data) =>`
	`473`	`+ PathParameters::AngleBracketed(fld.fold_angle_bracketed_parameter_data(data)),`
	`474`	`+ PathParameters::Parenthesized(data) =>`
	`475`	`+ PathParameters::Parenthesized(fld.fold_parenthesized_parameter_data(data)),`
`476`	`476`	`}`
`477`	`477`	`}`
`478`	`478`
Original file line number	Diff line number	Diff line change
`@@ -2403,7 +2403,7 @@ impl<'a> State<'a> {`
`2403`	`2403`	`}`
`2404`	`2404`
`2405`	`2405`	`match *parameters {`
`2406`		`- ast::AngleBracketedParameters(ref data) => {`
	`2406`	`+ ast::PathParameters::AngleBracketed(ref data) => {`
`2407`	`2407`	`try!(word(&mut self.s, "<"));`
`2408`	`2408`
`2409`	`2409`	`let mut comma = false;`
`@@ -2440,7 +2440,7 @@ impl<'a> State<'a> {`
`2440`	`2440`	`try!(word(&mut self.s, ">"))`
`2441`	`2441`	`}`
`2442`	`2442`
`2443`		`- ast::ParenthesizedParameters(ref data) => {`
	`2443`	`+ ast::PathParameters::Parenthesized(ref data) => {`
`2444`	`2444`	`try!(word(&mut self.s, "("));`
`2445`	`2445`	`try!(self.commasep(`
`2446`	`2446`	`Inconsistent,`