Give span to angle bracketed generic arguments

4 files changed, 18 insertions, 26 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 544afc5d6f6..4fc73787353 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -153,14 +153,10 @@ pub enum PathParameters {
 }
 
 impl PathParameters {
-    pub fn span(&self, fallback: Span) -> Span {
+    pub fn span(&self) -> Span {
         match *self {
-            AngleBracketed(ref data) => {
-                data.lifetimes.get(0).map(|x| x.span).or_else(||
-                data.types.get(0).map(|x| x.span)).or_else(||
-                data.bindings.get(0).map(|x| x.span)).unwrap_or(fallback)
-            }
-            Parenthesized(ref data) => data.span
+            AngleBracketed(ref data) => data.span,
+            Parenthesized(ref data) => data.span,
         }
     }
 }
@@ -168,6 +164,8 @@ impl PathParameters {
 /// A path like `Foo<'a, T>`
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Default)]
 pub struct AngleBracketedParameterData {
+    /// Overall span
+    pub span: Span,
     /// The lifetime parameters for this path segment.
     pub lifetimes: Vec<Lifetime>,
     /// The type parameters for this path segment, if present.
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index af9143eadbc..e004f7354eb 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -312,7 +312,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
         self.path_all(span, true, strs, Vec::new(), Vec::new(), Vec::new())
     }
     fn path_all(&self,
-                sp: Span,
+                span: Span,
                 global: bool,
                 mut idents: Vec<ast::Ident> ,
                 lifetimes: Vec<ast::Lifetime>,
@@ -322,24 +322,17 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
         let last_identifier = idents.pop().unwrap();
         let mut segments: Vec<ast::PathSegment> = Vec::new();
         if global {
-            segments.push(ast::PathSegment::crate_root(sp));
+            segments.push(ast::PathSegment::crate_root(span));
         }
 
-        segments.extend(idents.into_iter().map(|i| ast::PathSegment::from_ident(i, sp)));
+        segments.extend(idents.into_iter().map(|i| ast::PathSegment::from_ident(i, span)));
         let parameters = if !lifetimes.is_empty() || !types.is_empty() || !bindings.is_empty() {
-            ast::AngleBracketedParameterData { lifetimes, types, bindings }.into()
+            ast::AngleBracketedParameterData { lifetimes, types, bindings, span }.into()
         } else {
             None
         };
-        segments.push(ast::PathSegment {
-            identifier: last_identifier,
-            span: sp,
-            parameters: parameters
-        });
-        ast::Path {
-            span: sp,
-            segments: segments,
-        }
+        segments.push(ast::PathSegment { identifier: last_identifier, span, parameters });
+        ast::Path { span, segments }
     }
 
     /// Constructs a qualified path.
@@ -366,7 +359,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
                  -> (ast::QSelf, ast::Path) {
         let mut path = trait_path;
         let parameters = if !lifetimes.is_empty() || !types.is_empty() || !bindings.is_empty() {
-            ast::AngleBracketedParameterData { lifetimes, types, bindings }.into()
+            ast::AngleBracketedParameterData { lifetimes, types, bindings, span: ident.span }.into()
         } else {
             None
         };
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index eaec1eef172..8c616df858a 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -471,10 +471,11 @@ pub fn noop_fold_angle_bracketed_parameter_data<T: Folder>(data: AngleBracketedP
                                                            fld: &mut T)
                                                            -> AngleBracketedParameterData
 {
-    let AngleBracketedParameterData { lifetimes, types, bindings } = data;
+    let AngleBracketedParameterData { lifetimes, types, bindings, span } = data;
     AngleBracketedParameterData { lifetimes: fld.fold_lifetimes(lifetimes),
                                   types: types.move_map(|ty| fld.fold_ty(ty)),
-                                  bindings: bindings.move_map(|b| fld.fold_ty_binding(b)) }
+                                  bindings: bindings.move_map(|b| fld.fold_ty_binding(b)),
+                                  span: fld.new_span(span) }
 }
 
 pub fn noop_fold_parenthesized_parameter_data<T: Folder>(data: ParenthesizedParameterData,
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 833a10efa0b..d1591a219b3 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -1808,8 +1808,8 @@ impl<'a> Parser<'a> {
                 // `<'a, T, A = U>`
                 let (lifetimes, types, bindings) = self.parse_generic_args()?;
                 self.expect_gt()?;
-                let _span = lo.to(self.prev_span);
-                AngleBracketedParameterData { lifetimes, types, bindings }.into()
+                let span = lo.to(self.prev_span);
+                AngleBracketedParameterData { lifetimes, types, bindings, span }.into()
             } else {
                 // `(T, U) -> R`
                 self.bump(); // `(`
@@ -2357,7 +2357,7 @@ impl<'a> Parser<'a> {
             _ => {
                 // Field access `expr.f`
                 if let Some(parameters) = segment.parameters {
-                    self.span_err(parameters.span(segment.span),
+                    self.span_err(parameters.span(),
                                   "field expressions may not have generic arguments");
                 }