src/librustc_save_analysis/span_utils.rs

   1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use rustc::session::Session;
  12
  13 use generated_code;
  14
  15 use std::cell::Cell;
  16
  17 use syntax::parse::lexer::{self, StringReader};
  18 use syntax::parse::token::{self, Token};
  19 use syntax::symbol::keywords;
  20 use syntax_pos::*;
  21
  22 #[derive(Clone)]
  23 pub struct SpanUtils<'a> {
  24     pub sess: &'a Session,
  25     // FIXME given that we clone SpanUtils all over the place, this err_count is
  26     // probably useless and any logic relying on it is bogus.
  27     pub err_count: Cell<isize>,
  28 }
  29
  30 impl<'a> SpanUtils<'a> {
  31     pub fn new(sess: &'a Session) -> SpanUtils<'a> {
  32         SpanUtils {
  33             sess,
  34             err_count: Cell::new(0),
  35         }
  36     }
  37
  38     pub fn make_path_string(&self, path: &FileName) -> String {
  39         match *path {
  40             FileName::Real(ref path) if !path.is_absolute() =>
  41                 self.sess.working_dir.0
  42                     .join(&path)
  43                     .display()
  44                     .to_string(),
  45             _ => path.to_string(),
  46         }
  47     }
  48
  49     pub fn snippet(&self, span: Span) -> String {
  50         match self.sess.source_map().span_to_snippet(span) {
  51             Ok(s) => s,
  52             Err(_) => String::new(),
  53         }
  54     }
  55
  56     pub fn retokenise_span(&self, span: Span) -> StringReader<'a> {
  57         lexer::StringReader::retokenize(&self.sess.parse_sess, span)
  58     }
  59
  60     // Re-parses a path and returns the span for the last identifier in the path
  61     pub fn span_for_last_ident(&self, span: Span) -> Option<Span> {
  62         let mut result = None;
  63
  64         let mut toks = self.retokenise_span(span);
  65         let mut bracket_count = 0;
  66         loop {
  67             let ts = toks.real_token();
  68             if ts.tok == token::Eof {
  69                 return result;
  70             }
  71             if bracket_count == 0 && (ts.tok.is_ident() || ts.tok.is_keyword(keywords::SelfValue)) {
  72                 result = Some(ts.sp);
  73             }
  74
  75             bracket_count += match ts.tok {
  76                 token::Lt => 1,
  77                 token::Gt => -1,
  78                 token::BinOp(token::Shr) => -2,
  79                 _ => 0,
  80             }
  81         }
  82     }
  83
  84     // Return the span for the first identifier in the path.
  85     pub fn span_for_first_ident(&self, span: Span) -> Option<Span> {
  86         let mut toks = self.retokenise_span(span);
  87         let mut bracket_count = 0;
  88         loop {
  89             let ts = toks.real_token();
  90             if ts.tok == token::Eof {
  91                 return None;
  92             }
  93             if bracket_count == 0 && (ts.tok.is_ident() || ts.tok.is_keyword(keywords::SelfValue)) {
  94                 return Some(ts.sp);
  95             }
  96
  97             bracket_count += match ts.tok {
  98                 token::Lt => 1,
  99                 token::Gt => -1,
 100                 token::BinOp(token::Shr) => -2,
 101                 _ => 0,
 102             }
 103         }
 104     }
 105
 106     // Return the span for the last ident before a `<` and outside any
 107     // angle brackets, or the last span.
 108     pub fn sub_span_for_type_name(&self, span: Span) -> Option<Span> {
 109         let mut toks = self.retokenise_span(span);
 110         let mut prev = toks.real_token();
 111         let mut result = None;
 112
 113         // We keep track of the following two counts - the depth of nesting of
 114         // angle brackets, and the depth of nesting of square brackets. For the
 115         // angle bracket count, we only count tokens which occur outside of any
 116         // square brackets (i.e. bracket_count == 0). The intuition here is
 117         // that we want to count angle brackets in the type, but not any which
 118         // could be in expression context (because these could mean 'less than',
 119         // etc.).
 120         let mut angle_count = 0;
 121         let mut bracket_count = 0;
 122         loop {
 123             let next = toks.real_token();
 124
 125             if (next.tok == token::Lt || next.tok == token::Colon) && angle_count == 0
 126                 && bracket_count == 0 && prev.tok.is_ident()
 127             {
 128                 result = Some(prev.sp);
 129             }
 130
 131             if bracket_count == 0 {
 132                 angle_count += match prev.tok {
 133                     token::Lt => 1,
 134                     token::Gt => -1,
 135                     token::BinOp(token::Shl) => 2,
 136                     token::BinOp(token::Shr) => -2,
 137                     _ => 0,
 138                 };
 139             }
 140
 141             bracket_count += match prev.tok {
 142                 token::OpenDelim(token::Bracket) => 1,
 143                 token::CloseDelim(token::Bracket) => -1,
 144                 _ => 0,
 145             };
 146
 147             if next.tok == token::Eof {
 148                 break;
 149             }
 150             prev = next;
 151         }
 152         #[cfg(debug_assertions)] {
 153             if angle_count != 0 || bracket_count != 0 {
 154                 let loc = self.sess.source_map().lookup_char_pos(span.lo());
 155                 span_bug!(
 156                     span,
 157                     "Mis-counted brackets when breaking path? Parsing '{}' in {}, line {}",
 158                     self.snippet(span),
 159                     loc.file.name,
 160                     loc.line
 161                 );
 162             }
 163         }
 164         if result.is_none() && prev.tok.is_ident() {
 165             return Some(prev.sp);
 166         }
 167         result
 168     }
 169
 170     pub fn sub_span_before_token(&self, span: Span, tok: Token) -> Option<Span> {
 171         let mut toks = self.retokenise_span(span);
 172         let mut prev = toks.real_token();
 173         loop {
 174             if prev.tok == token::Eof {
 175                 return None;
 176             }
 177             let next = toks.real_token();
 178             if next.tok == tok {
 179                 return Some(prev.sp);
 180             }
 181             prev = next;
 182         }
 183     }
 184
 185     pub fn sub_span_of_token(&self, span: Span, tok: Token) -> Option<Span> {
 186         let mut toks = self.retokenise_span(span);
 187         loop {
 188             let next = toks.real_token();
 189             if next.tok == token::Eof {
 190                 return None;
 191             }
 192             if next.tok == tok {
 193                 return Some(next.sp);
 194             }
 195         }
 196     }
 197
 198     pub fn sub_span_after_keyword(&self, span: Span, keyword: keywords::Keyword) -> Option<Span> {
 199         self.sub_span_after(span, |t| t.is_keyword(keyword))
 200     }
 201
 202     fn sub_span_after<F: Fn(Token) -> bool>(&self, span: Span, f: F) -> Option<Span> {
 203         let mut toks = self.retokenise_span(span);
 204         loop {
 205             let ts = toks.real_token();
 206             if ts.tok == token::Eof {
 207                 return None;
 208             }
 209             if f(ts.tok) {
 210                 let ts = toks.real_token();
 211                 if ts.tok == token::Eof {
 212                     return None;
 213                 } else {
 214                     return Some(ts.sp);
 215                 }
 216             }
 217         }
 218     }
 219
 220     // // Return the name for a macro definition (identifier after first `!`)
 221     // pub fn span_for_macro_def_name(&self, span: Span) -> Option<Span> {
 222     //     let mut toks = self.retokenise_span(span);
 223     //     loop {
 224     //         let ts = toks.real_token();
 225     //         if ts.tok == token::Eof {
 226     //             return None;
 227     //         }
 228     //         if ts.tok == token::Not {
 229     //             let ts = toks.real_token();
 230     //             if ts.tok.is_ident() {
 231     //                 return Some(ts.sp);
 232     //             } else {
 233     //                 return None;
 234     //             }
 235     //         }
 236     //     }
 237     // }
 238
 239     // // Return the name for a macro use (identifier before first `!`).
 240     // pub fn span_for_macro_use_name(&self, span:Span) -> Option<Span> {
 241     //     let mut toks = self.retokenise_span(span);
 242     //     let mut prev = toks.real_token();
 243     //     loop {
 244     //         if prev.tok == token::Eof {
 245     //             return None;
 246     //         }
 247     //         let ts = toks.real_token();
 248     //         if ts.tok == token::Not {
 249     //             if prev.tok.is_ident() {
 250     //                 return Some(prev.sp);
 251     //             } else {
 252     //                 return None;
 253     //             }
 254     //         }
 255     //         prev = ts;
 256     //     }
 257     // }
 258
 259     /// Return true if the span is generated code, and
 260     /// it is not a subspan of the root callsite.
 261     ///
 262     /// Used to filter out spans of minimal value,
 263     /// such as references to macro internal variables.
 264     pub fn filter_generated(&self, sub_span: Option<Span>, parent: Span) -> bool {
 265         if !generated_code(parent) {
 266             // Edge case - this occurs on generated code with incorrect expansion info.
 267             return sub_span.is_none()
 268         }
 269         // If sub_span is none, filter out generated code.
 270         let sub_span = match sub_span {
 271             Some(ss) => ss,
 272             None => return true,
 273         };
 274
 275         //If the span comes from a fake source_file, filter it.
 276         if !self.sess
 277             .source_map()
 278             .lookup_char_pos(parent.lo())
 279             .file
 280             .is_real_file()
 281         {
 282             return true;
 283         }
 284
 285         // Otherwise, a generated span is deemed invalid if it is not a sub-span of the root
 286         // callsite. This filters out macro internal variables and most malformed spans.
 287         !parent.source_callsite().contains(sub_span)
 288     }
 289 }
 290
 291 macro_rules! filter {
 292     ($util: expr, $span: expr, $parent: expr, None) => {
 293         if $util.filter_generated($span, $parent) {
 294             return None;
 295         }
 296     };
 297     ($util: expr, $span: ident, $parent: expr) => {
 298         if $util.filter_generated($span, $parent) {
 299             return;
 300         }
 301     };
 302 }