comments

[rust.git] / src / librustc_trans / save / span_utils.rs

diff --git a/src/librustc_trans/save/span_utils.rs b/src/librustc_trans/save/span_utils.rs
index ba027e4c2d192141de56011b93cb0c5bb7465ca6..c3ac805af27ec1fcd6b5d684af0f353cb987b93d 100644 (file)
--- a/src/librustc_trans/save/span_utils.rs
+++ b/src/librustc_trans/save/span_utils.rs
@@ -230,8 +230,8 @@ pub fn sub_span_for_type_name(&self, span: Span) -> Option<Span> {
     // Reparse span and return an owned vector of sub spans of the first limit
     // identifier tokens in the given nesting level.
     // example with Foo<Bar<T,V>, Bar<T,V>>
-    // Nesting = 0: all idents outside of brackets: Vec<Foo>
-    // Nesting = 1: idents within one level of brackets: Vec<Bar, Bar>
+    // Nesting = 0: all idents outside of brackets: [Foo]
+    // Nesting = 1: idents within one level of brackets: [Bar, Bar]
     pub fn spans_with_brackets(&self, span: Span, nesting: isize, limit: isize) -> Vec<Span> {
         let mut result: Vec<Span> = vec!();
 
@@ -260,10 +260,20 @@ pub fn spans_with_brackets(&self, span: Span, nesting: isize, limit: isize) -> V
                 token::BinOp(token::Shr) => -2,
                 _ => 0
             };
+
             // Ignore the `>::` in `<Type as Trait>::AssocTy`.
+
+            // The root cause of this hack is that the AST representation of
+            // qpaths is horrible. It treats <A as B>::C as a path with two
+            // segments, B and C and notes that there is also a self type A at
+            // position 0. Because we don't have spans for individual idents,
+            // only the whole path, we have to iterate over the tokens in the
+            // path, trying to pull out the non-nested idents (e.g., avoiding 'a
+            // in `<A as B<'a>>::C`). So we end up with a span for `B>::C` from
+            // the start of the first ident to the end of the path.
             if !found_ufcs_sep && bracket_count == -1 {
                 found_ufcs_sep = true;
-                bracket_count += 1
+                bracket_count += 1;
             }
             if ts.tok.is_ident() && bracket_count == nesting {
                 result.push(self.make_sub_span(span, Some(ts.sp)).unwrap());
@@ -332,7 +342,7 @@ fn sub_span_after<F: Fn(Token) -> bool>(&self,
     }
 
 
-    // Returns a list of the spans of idents in a patch.
+    // Returns a list of the spans of idents in a path.
     // E.g., For foo::bar<x,t>::baz, we return [foo, bar, baz] (well, their spans)
     pub fn spans_for_path_segments(&self, path: &ast::Path) -> Vec<Span> {
         if generated_code(path.span) {