use rustc::hir::def::Def as HirDef;
use rustc::hir::def_id::DefId;
+use rustc::session::config::Input;
use rustc::ty::{self, TyCtxt};
use rustc_data_structures::fx::FxHashSet;
use std::path::Path;
+use std::env;
use syntax::ast::{self, Attribute, NodeId, PatKind, CRATE_NODE_ID};
use syntax::parse::token;
use span_utils::SpanUtils;
use sig;
-use rls_data::{CratePreludeData, Def, DefKind, GlobalCrateId, Import, ImportKind, Ref, RefKind,
- Relation, RelationKind, SpanData};
+use rls_data::{CompilationOptions, CratePreludeData, Def, DefKind, GlobalCrateId, Import,
+ ImportKind, Ref, RefKind, Relation, RelationKind, SpanData};
macro_rules! down_cast_data {
($id:ident, $kind:ident, $sp:expr) => {
let crate_root = source_file.map(|source_file| {
let source_file = Path::new(source_file);
match source_file.file_name() {
- Some(_) => source_file.parent().unwrap().display().to_string(),
- None => source_file.display().to_string(),
- }
+ Some(_) => source_file.parent().unwrap().display(),
+ None => source_file.display(),
+ }.to_string()
});
let data = CratePreludeData {
self.dumper.crate_prelude(data);
}
+ pub fn dump_compilation_options(&mut self, input: &Input, crate_name: &str) {
+ // Apply possible `remap-path-prefix` remapping to the input source file
+ // (and don't include remapping args anymore)
+ let (program, arguments) = {
+ let remap_arg_indices = {
+ let mut indices = FxHashSet();
+ // Args are guaranteed to be valid UTF-8 (checked early)
+ for (i, e) in env::args().enumerate() {
+ if e.starts_with("--remap-path-prefix=") {
+ indices.insert(i);
+ } else if e == "--remap-path-prefix" {
+ indices.insert(i);
+ indices.insert(i + 1);
+ }
+ }
+ indices
+ };
+
+ let mut args = env::args()
+ .enumerate()
+ .filter(|(i, _)| !remap_arg_indices.contains(i))
+ .map(|(_, arg)| {
+ match input {
+ Input::File(ref path) if path == Path::new(&arg) => {
+ let mapped = &self.tcx.sess.local_crate_source_file;
+ mapped
+ .as_ref()
+ .unwrap()
+ .to_string_lossy()
+ .into()
+ },
+ _ => arg,
+ }
+ });
+
+ (args.next().unwrap(), args.collect())
+ };
+
+ let data = CompilationOptions {
+ directory: self.tcx.sess.working_dir.0.clone(),
+ program,
+ arguments,
+ output: self.save_ctxt.compilation_output(crate_name),
+ };
+
+ self.dumper.compilation_opts(data);
+ }
+
// Return all non-empty prefixes of a path.
// For each prefix, we return the span for the last segment in the prefix and
// a str representation of the entire prefix.
let segments = &path.segments[if path.is_global() { 1 } else { 0 }..];
let mut result = Vec::with_capacity(segments.len());
+ let mut segs = Vec::with_capacity(segments.len());
- let mut segs = vec![];
for (i, seg) in segments.iter().enumerate() {
segs.push(seg.clone());
let sub_path = ast::Path {
for variant in &enum_definition.variants {
let name = variant.node.ident.name.to_string();
- let mut qualname = enum_data.qualname.clone();
- qualname.push_str("::");
- qualname.push_str(&name);
+ let qualname = format!("{}::{}", enum_data.qualname, name);
match variant.node.data {
ast::VariantData::Struct(ref fields, _) => {
match self.save_ctxt.get_path_def(id) {
HirDef::Local(id) => {
let mut value = if immut == ast::Mutability::Immutable {
- self.span.snippet(ident.span).to_string()
+ self.span.snippet(ident.span)
} else {
- "<mutable>".to_string()
+ "<mutable>".to_owned()
};
let hir_id = self.tcx.hir.node_to_hir_id(id);
let typ = self.save_ctxt
/// mac_uses and mac_defs sets to prevent multiples.
fn process_macro_use(&mut self, span: Span) {
let source_span = span.source_callsite();
- if self.macro_calls.contains(&source_span) {
+ if !self.macro_calls.insert(source_span) {
return;
}
- self.macro_calls.insert(source_span);
let data = match self.save_ctxt.get_macro_use_data(span) {
None => return,
}
}
}
+
+ fn process_bounds(&mut self, bounds: &'l ast::GenericBounds) {
+ for bound in bounds {
+ if let ast::GenericBound::Trait(ref trait_ref, _) = *bound {
+ self.process_path(trait_ref.trait_ref.ref_id, &trait_ref.trait_ref.path)
+ }
+ }
+ }
}
impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> Visitor<'l> for DumpVisitor<'l, 'tcx, 'll, O> {
fn visit_generics(&mut self, generics: &'l ast::Generics) {
for param in &generics.params {
- match param.kind {
- ast::GenericParamKind::Lifetime { .. } => {}
- ast::GenericParamKind::Type { ref default, .. } => {
- for bound in ¶m.bounds {
- if let ast::GenericBound::Trait(ref trait_ref, _) = *bound {
- self.process_path(trait_ref.trait_ref.ref_id, &trait_ref.trait_ref.path)
- }
- }
- if let Some(ref ty) = default {
- self.visit_ty(&ty);
- }
+ if let ast::GenericParamKind::Type { ref default, .. } = param.kind {
+ self.process_bounds(¶m.bounds);
+ if let Some(ref ty) = default {
+ self.visit_ty(&ty);
}
}
}
+ for pred in &generics.where_clause.predicates {
+ if let ast::WherePredicate::BoundPredicate(ref wbp) = *pred {
+ self.process_bounds(&wbp.bounds);
+ self.visit_ty(&wbp.bounded_ty);
+ }
+ }
}
fn visit_ty(&mut self, t: &'l ast::Ty) {
}
}
ast::ExprKind::Closure(_, _, _, ref decl, ref body, _fn_decl_span) => {
- let mut id = String::from("$");
- id.push_str(&ex.id.to_string());
+ let id = format!("${}", ex.id);
// walk arg and return types
for arg in &decl.inputs {
fn visit_arm(&mut self, arm: &'l ast::Arm) {
self.process_var_decl_multi(&arm.pats);
- walk_list!(self, visit_expr, &arm.guard);
+ match arm.guard {
+ Some(ast::Guard::If(ref expr)) => self.visit_expr(expr),
+ _ => {}
+ }
self.visit_expr(&arm.body);
}
projects / rust.git / blobdiff