diff options
| author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-17 12:02:58 +0000 |
|---|---|---|
| committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-17 12:02:58 +0000 |
| commit | 698f8c2f01ea549d77d7dc3338a12e04c11057b9 (patch) | |
| tree | 173a775858bd501c378080a10dca74132f05bc50 /compiler/rustc_save_analysis | |
| parent | Initial commit. (diff) | |
| download | rustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.tar.xz rustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.zip | |
Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'compiler/rustc_save_analysis')
| -rw-r--r-- | compiler/rustc_save_analysis/Cargo.toml | 19 | ||||
| -rw-r--r-- | compiler/rustc_save_analysis/src/dump_visitor.rs | 1463 | ||||
| -rw-r--r-- | compiler/rustc_save_analysis/src/dumper.rs | 91 | ||||
| -rw-r--r-- | compiler/rustc_save_analysis/src/lib.rs | 1075 | ||||
| -rw-r--r-- | compiler/rustc_save_analysis/src/sig.rs | 917 | ||||
| -rw-r--r-- | compiler/rustc_save_analysis/src/span_utils.rs | 102 |
6 files changed, 3667 insertions, 0 deletions
diff --git a/compiler/rustc_save_analysis/Cargo.toml b/compiler/rustc_save_analysis/Cargo.toml new file mode 100644 index 000000000..15a89d82f --- /dev/null +++ b/compiler/rustc_save_analysis/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "rustc_save_analysis" +version = "0.0.0" +edition = "2021" + +[dependencies] +tracing = "0.1" +rustc_middle = { path = "../rustc_middle" } +rustc_ast = { path = "../rustc_ast" } +rustc_ast_pretty = { path = "../rustc_ast_pretty" } +rustc_data_structures = { path = "../rustc_data_structures" } +rustc_hir = { path = "../rustc_hir" } +rustc_hir_pretty = { path = "../rustc_hir_pretty" } +rustc_lexer = { path = "../rustc_lexer" } +serde_json = "1" +rustc_session = { path = "../rustc_session" } +rustc_span = { path = "../rustc_span" } +rls-data = "0.19" +rls-span = "0.5" diff --git a/compiler/rustc_save_analysis/src/dump_visitor.rs b/compiler/rustc_save_analysis/src/dump_visitor.rs new file mode 100644 index 000000000..e2e0e1f5b --- /dev/null +++ b/compiler/rustc_save_analysis/src/dump_visitor.rs @@ -0,0 +1,1463 @@ +//! Write the output of rustc's analysis to an implementor of Dump. +//! +//! Dumping the analysis is implemented by walking the AST and getting a bunch of +//! info out from all over the place. We use `DefId`s to identify objects. The +//! tricky part is getting syntactic (span, source text) and semantic (reference +//! `DefId`s) information for parts of expressions which the compiler has discarded. +//! E.g., in a path `foo::bar::baz`, the compiler only keeps a span for the whole +//! path and a reference to `baz`, but we want spans and references for all three +//! idents. +//! +//! SpanUtils is used to manipulate spans. In particular, to extract sub-spans +//! from spans (e.g., the span for `bar` from the above example path). +//! DumpVisitor walks the AST and processes it, and Dumper is used for +//! recording the output. + +use rustc_ast as ast; +use rustc_ast::walk_list; +use rustc_data_structures::fx::FxHashSet; +use rustc_hir as hir; +use rustc_hir::def::{DefKind as HirDefKind, Res}; +use rustc_hir::def_id::{DefId, LocalDefId, CRATE_DEF_ID}; +use rustc_hir::intravisit::{self, Visitor}; +use rustc_hir_pretty::{bounds_to_string, fn_to_string, generic_params_to_string, ty_to_string}; +use rustc_middle::hir::nested_filter; +use rustc_middle::span_bug; +use rustc_middle::ty::{self, DefIdTree, TyCtxt}; +use rustc_session::config::Input; +use rustc_span::symbol::Ident; +use rustc_span::*; + +use std::env; +use std::path::Path; + +use crate::dumper::{Access, Dumper}; +use crate::sig; +use crate::span_utils::SpanUtils; +use crate::{ + escape, generated_code, id_from_def_id, id_from_hir_id, lower_attributes, PathCollector, + SaveContext, +}; + +use rls_data::{ + CompilationOptions, CratePreludeData, Def, DefKind, GlobalCrateId, Import, ImportKind, Ref, + RefKind, Relation, RelationKind, SpanData, +}; + +use tracing::{debug, error}; + +#[rustfmt::skip] // https://github.com/rust-lang/rustfmt/issues/5213 +macro_rules! down_cast_data { + ($id:ident, $kind:ident, $sp:expr) => { + let super::Data::$kind($id) = $id else { + span_bug!($sp, "unexpected data kind: {:?}", $id); + }; + }; +} + +macro_rules! access_from { + ($save_ctxt:expr, $id:expr) => { + Access { + public: $save_ctxt.tcx.visibility($id).is_public(), + reachable: $save_ctxt.access_levels.is_reachable($id), + } + }; +} + +pub struct DumpVisitor<'tcx> { + pub save_ctxt: SaveContext<'tcx>, + tcx: TyCtxt<'tcx>, + dumper: Dumper, + + span: SpanUtils<'tcx>, + // Set of macro definition (callee) spans, and the set + // of macro use (callsite) spans. We store these to ensure + // we only write one macro def per unique macro definition, and + // one macro use per unique callsite span. + // mac_defs: FxHashSet<Span>, + // macro_calls: FxHashSet<Span>, +} + +impl<'tcx> DumpVisitor<'tcx> { + pub fn new(save_ctxt: SaveContext<'tcx>) -> DumpVisitor<'tcx> { + let span_utils = SpanUtils::new(&save_ctxt.tcx.sess); + let dumper = Dumper::new(save_ctxt.config.clone()); + DumpVisitor { tcx: save_ctxt.tcx, save_ctxt, dumper, span: span_utils } + } + + pub fn analysis(&self) -> &rls_data::Analysis { + self.dumper.analysis() + } + + fn nest_typeck_results<F>(&mut self, item_def_id: LocalDefId, f: F) + where + F: FnOnce(&mut Self), + { + let typeck_results = if self.tcx.has_typeck_results(item_def_id) { + Some(self.tcx.typeck(item_def_id)) + } else { + None + }; + + let old_maybe_typeck_results = self.save_ctxt.maybe_typeck_results; + self.save_ctxt.maybe_typeck_results = typeck_results; + f(self); + self.save_ctxt.maybe_typeck_results = old_maybe_typeck_results; + } + + fn span_from_span(&self, span: Span) -> SpanData { + self.save_ctxt.span_from_span(span) + } + + fn lookup_def_id(&self, ref_id: hir::HirId) -> Option<DefId> { + self.save_ctxt.lookup_def_id(ref_id) + } + + pub fn dump_crate_info(&mut self, name: &str) { + let source_file = self.tcx.sess.local_crate_source_file.as_ref(); + 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(), + None => source_file.display(), + } + .to_string() + }); + + let data = CratePreludeData { + crate_id: GlobalCrateId { + name: name.into(), + disambiguator: (self.tcx.sess.local_stable_crate_id().to_u64(), 0), + }, + crate_root: crate_root.unwrap_or_else(|| "<no source>".to_owned()), + external_crates: self.save_ctxt.get_external_crates(), + span: self.span_from_span(self.tcx.def_span(CRATE_DEF_ID)), + }; + + 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::default(); + // 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.opts.working_dir.remapped_path_if_available().into(), + program, + arguments, + output: self.save_ctxt.compilation_output(crate_name), + }; + + self.dumper.compilation_opts(data); + } + + fn write_segments(&mut self, segments: impl IntoIterator<Item = &'tcx hir::PathSegment<'tcx>>) { + for seg in segments { + if let Some(data) = self.save_ctxt.get_path_segment_data(seg) { + self.dumper.dump_ref(data); + } + } + } + + fn write_sub_paths(&mut self, path: &'tcx hir::Path<'tcx>) { + self.write_segments(path.segments) + } + + // As write_sub_paths, but does not process the last ident in the path (assuming it + // will be processed elsewhere). See note on write_sub_paths about global. + fn write_sub_paths_truncated(&mut self, path: &'tcx hir::Path<'tcx>) { + if let [segments @ .., _] = path.segments { + self.write_segments(segments) + } + } + + fn process_formals(&mut self, formals: &'tcx [hir::Param<'tcx>], qualname: &str) { + for arg in formals { + self.visit_pat(&arg.pat); + let mut collector = PathCollector::new(self.tcx); + collector.visit_pat(&arg.pat); + + for (hir_id, ident, ..) in collector.collected_idents { + let typ = match self.save_ctxt.typeck_results().node_type_opt(hir_id) { + Some(s) => s.to_string(), + None => continue, + }; + if !self.span.filter_generated(ident.span) { + let id = id_from_hir_id(hir_id, &self.save_ctxt); + let span = self.span_from_span(ident.span); + + self.dumper.dump_def( + &Access { public: false, reachable: false }, + Def { + kind: DefKind::Local, + id, + span, + name: ident.to_string(), + qualname: format!("{}::{}", qualname, ident), + value: typ, + parent: None, + children: vec![], + decl_id: None, + docs: String::new(), + sig: None, + attributes: vec![], + }, + ); + } + } + } + } + + fn process_method( + &mut self, + sig: &'tcx hir::FnSig<'tcx>, + body: Option<hir::BodyId>, + def_id: LocalDefId, + ident: Ident, + generics: &'tcx hir::Generics<'tcx>, + span: Span, + ) { + debug!("process_method: {:?}:{}", def_id, ident); + + let map = self.tcx.hir(); + let hir_id = map.local_def_id_to_hir_id(def_id); + self.nest_typeck_results(def_id, |v| { + if let Some(mut method_data) = v.save_ctxt.get_method_data(hir_id, ident, span) { + if let Some(body) = body { + v.process_formals(map.body(body).params, &method_data.qualname); + } + v.process_generic_params(&generics, &method_data.qualname, hir_id); + + method_data.value = + fn_to_string(sig.decl, sig.header, Some(ident.name), generics, &[], None); + method_data.sig = sig::method_signature(hir_id, ident, generics, sig, &v.save_ctxt); + + v.dumper.dump_def(&access_from!(v.save_ctxt, def_id), method_data); + } + + // walk arg and return types + for arg in sig.decl.inputs { + v.visit_ty(arg); + } + + if let hir::FnRetTy::Return(ref ret_ty) = sig.decl.output { + v.visit_ty(ret_ty) + } + + // walk the fn body + if let Some(body) = body { + v.visit_expr(&map.body(body).value); + } + }); + } + + fn process_struct_field_def( + &mut self, + field: &'tcx hir::FieldDef<'tcx>, + parent_id: hir::HirId, + ) { + let field_data = self.save_ctxt.get_field_data(field, parent_id); + if let Some(field_data) = field_data { + self.dumper.dump_def( + &access_from!(self.save_ctxt, self.tcx.hir().local_def_id(field.hir_id)), + field_data, + ); + } + } + + // Dump generic params bindings, then visit_generics + fn process_generic_params( + &mut self, + generics: &'tcx hir::Generics<'tcx>, + prefix: &str, + id: hir::HirId, + ) { + for param in generics.params { + match param.kind { + hir::GenericParamKind::Lifetime { .. } => {} + hir::GenericParamKind::Type { .. } => { + let param_ss = param.name.ident().span; + let name = escape(self.span.snippet(param_ss)); + // Append $id to name to make sure each one is unique. + let qualname = format!("{}::{}${}", prefix, name, id); + if !self.span.filter_generated(param_ss) { + let id = id_from_hir_id(param.hir_id, &self.save_ctxt); + let span = self.span_from_span(param_ss); + + self.dumper.dump_def( + &Access { public: false, reachable: false }, + Def { + kind: DefKind::Type, + id, + span, + name, + qualname, + value: String::new(), + parent: None, + children: vec![], + decl_id: None, + docs: String::new(), + sig: None, + attributes: vec![], + }, + ); + } + } + hir::GenericParamKind::Const { .. } => {} + } + } + + self.visit_generics(generics) + } + + fn process_fn( + &mut self, + item: &'tcx hir::Item<'tcx>, + decl: &'tcx hir::FnDecl<'tcx>, + _header: &'tcx hir::FnHeader, + ty_params: &'tcx hir::Generics<'tcx>, + body: hir::BodyId, + ) { + let map = self.tcx.hir(); + self.nest_typeck_results(item.def_id, |v| { + let body = map.body(body); + if let Some(fn_data) = v.save_ctxt.get_item_data(item) { + down_cast_data!(fn_data, DefData, item.span); + v.process_formals(body.params, &fn_data.qualname); + v.process_generic_params(ty_params, &fn_data.qualname, item.hir_id()); + + v.dumper.dump_def(&access_from!(v.save_ctxt, item.def_id), fn_data); + } + + for arg in decl.inputs { + v.visit_ty(arg) + } + + if let hir::FnRetTy::Return(ref ret_ty) = decl.output { + v.visit_ty(ret_ty) + } + + v.visit_expr(&body.value); + }); + } + + fn process_static_or_const_item( + &mut self, + item: &'tcx hir::Item<'tcx>, + typ: &'tcx hir::Ty<'tcx>, + expr: &'tcx hir::Expr<'tcx>, + ) { + self.nest_typeck_results(item.def_id, |v| { + if let Some(var_data) = v.save_ctxt.get_item_data(item) { + down_cast_data!(var_data, DefData, item.span); + v.dumper.dump_def(&access_from!(v.save_ctxt, item.def_id), var_data); + } + v.visit_ty(&typ); + v.visit_expr(expr); + }); + } + + fn process_assoc_const( + &mut self, + def_id: LocalDefId, + ident: Ident, + typ: &'tcx hir::Ty<'tcx>, + expr: Option<&'tcx hir::Expr<'tcx>>, + parent_id: DefId, + attrs: &'tcx [ast::Attribute], + ) { + let qualname = format!("::{}", self.tcx.def_path_str(def_id.to_def_id())); + + if !self.span.filter_generated(ident.span) { + let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); + let sig = sig::assoc_const_signature(hir_id, ident.name, typ, expr, &self.save_ctxt); + let span = self.span_from_span(ident.span); + + self.dumper.dump_def( + &access_from!(self.save_ctxt, def_id), + Def { + kind: DefKind::Const, + id: id_from_hir_id(hir_id, &self.save_ctxt), + span, + name: ident.name.to_string(), + qualname, + value: ty_to_string(&typ), + parent: Some(id_from_def_id(parent_id)), + children: vec![], + decl_id: None, + docs: self.save_ctxt.docs_for_attrs(attrs), + sig, + attributes: lower_attributes(attrs.to_owned(), &self.save_ctxt), + }, + ); + } + + // walk type and init value + self.nest_typeck_results(def_id, |v| { + v.visit_ty(typ); + if let Some(expr) = expr { + v.visit_expr(expr); + } + }); + } + + // FIXME tuple structs should generate tuple-specific data. + fn process_struct( + &mut self, + item: &'tcx hir::Item<'tcx>, + def: &'tcx hir::VariantData<'tcx>, + ty_params: &'tcx hir::Generics<'tcx>, + ) { + debug!("process_struct {:?} {:?}", item, item.span); + let name = item.ident.to_string(); + let qualname = format!("::{}", self.tcx.def_path_str(item.def_id.to_def_id())); + + let kind = match item.kind { + hir::ItemKind::Struct(_, _) => DefKind::Struct, + hir::ItemKind::Union(_, _) => DefKind::Union, + _ => unreachable!(), + }; + + let (value, fields) = match item.kind { + hir::ItemKind::Struct(hir::VariantData::Struct(ref fields, ..), ..) + | hir::ItemKind::Union(hir::VariantData::Struct(ref fields, ..), ..) => { + let include_priv_fields = !self.save_ctxt.config.pub_only; + let fields_str = fields + .iter() + .filter_map(|f| { + if include_priv_fields { + return Some(f.ident.to_string()); + } + let def_id = self.save_ctxt.tcx.hir().local_def_id(f.hir_id); + if self.save_ctxt.tcx.visibility(def_id).is_public() { + Some(f.ident.to_string()) + } else { + None + } + }) + .collect::<Vec<_>>() + .join(", "); + let value = format!("{} {{ {} }}", name, fields_str); + (value, fields.iter().map(|f| id_from_hir_id(f.hir_id, &self.save_ctxt)).collect()) + } + _ => (String::new(), vec![]), + }; + + if !self.span.filter_generated(item.ident.span) { + let span = self.span_from_span(item.ident.span); + let attrs = self.tcx.hir().attrs(item.hir_id()); + self.dumper.dump_def( + &access_from!(self.save_ctxt, item.def_id), + Def { + kind, + id: id_from_def_id(item.def_id.to_def_id()), + span, + name, + qualname: qualname.clone(), + value, + parent: None, + children: fields, + decl_id: None, + docs: self.save_ctxt.docs_for_attrs(attrs), + sig: sig::item_signature(item, &self.save_ctxt), + attributes: lower_attributes(attrs.to_vec(), &self.save_ctxt), + }, + ); + } + + self.nest_typeck_results(item.def_id, |v| { + for field in def.fields() { + v.process_struct_field_def(field, item.hir_id()); + v.visit_ty(&field.ty); + } + + v.process_generic_params(ty_params, &qualname, item.hir_id()); + }); + } + + fn process_enum( + &mut self, + item: &'tcx hir::Item<'tcx>, + enum_definition: &'tcx hir::EnumDef<'tcx>, + ty_params: &'tcx hir::Generics<'tcx>, + ) { + let enum_data = self.save_ctxt.get_item_data(item); + let Some(enum_data) = enum_data else { + return; + }; + down_cast_data!(enum_data, DefData, item.span); + + let access = access_from!(self.save_ctxt, item.def_id); + + for variant in enum_definition.variants { + let name = variant.ident.name.to_string(); + let qualname = format!("{}::{}", enum_data.qualname, name); + let name_span = variant.ident.span; + + match variant.data { + hir::VariantData::Struct(ref fields, ..) => { + let fields_str = + fields.iter().map(|f| f.ident.to_string()).collect::<Vec<_>>().join(", "); + let value = format!("{}::{} {{ {} }}", enum_data.name, name, fields_str); + if !self.span.filter_generated(name_span) { + let span = self.span_from_span(name_span); + let id = id_from_hir_id(variant.id, &self.save_ctxt); + let parent = Some(id_from_def_id(item.def_id.to_def_id())); + let attrs = self.tcx.hir().attrs(variant.id); + + self.dumper.dump_def( + &access, + Def { + kind: DefKind::StructVariant, + id, + span, + name, + qualname, + value, + parent, + children: vec![], + decl_id: None, + docs: self.save_ctxt.docs_for_attrs(attrs), + sig: sig::variant_signature(variant, &self.save_ctxt), + attributes: lower_attributes(attrs.to_vec(), &self.save_ctxt), + }, + ); + } + } + ref v => { + let mut value = format!("{}::{}", enum_data.name, name); + if let hir::VariantData::Tuple(fields, _) = v { + value.push('('); + value.push_str( + &fields + .iter() + .map(|f| ty_to_string(&f.ty)) + .collect::<Vec<_>>() + .join(", "), + ); + value.push(')'); + } + if !self.span.filter_generated(name_span) { + let span = self.span_from_span(name_span); + let id = id_from_hir_id(variant.id, &self.save_ctxt); + let parent = Some(id_from_def_id(item.def_id.to_def_id())); + let attrs = self.tcx.hir().attrs(variant.id); + + self.dumper.dump_def( + &access, + Def { + kind: DefKind::TupleVariant, + id, + span, + name, + qualname, + value, + parent, + children: vec![], + decl_id: None, + docs: self.save_ctxt.docs_for_attrs(attrs), + sig: sig::variant_signature(variant, &self.save_ctxt), + attributes: lower_attributes(attrs.to_vec(), &self.save_ctxt), + }, + ); + } + } + } + + for field in variant.data.fields() { + self.process_struct_field_def(field, variant.id); + self.visit_ty(field.ty); + } + } + self.process_generic_params(ty_params, &enum_data.qualname, item.hir_id()); + self.dumper.dump_def(&access, enum_data); + } + + fn process_impl(&mut self, item: &'tcx hir::Item<'tcx>, impl_: &'tcx hir::Impl<'tcx>) { + if let Some(impl_data) = self.save_ctxt.get_item_data(item) { + if !self.span.filter_generated(item.span) { + if let super::Data::RelationData(rel, imp) = impl_data { + self.dumper.dump_relation(rel); + self.dumper.dump_impl(imp); + } else { + span_bug!(item.span, "unexpected data kind: {:?}", impl_data); + } + } + } + + let map = self.tcx.hir(); + self.nest_typeck_results(item.def_id, |v| { + v.visit_ty(&impl_.self_ty); + if let Some(trait_ref) = &impl_.of_trait { + v.process_path(trait_ref.hir_ref_id, &hir::QPath::Resolved(None, &trait_ref.path)); + } + v.process_generic_params(&impl_.generics, "", item.hir_id()); + for impl_item in impl_.items { + v.process_impl_item(map.impl_item(impl_item.id), item.def_id.to_def_id()); + } + }); + } + + fn process_trait( + &mut self, + item: &'tcx hir::Item<'tcx>, + generics: &'tcx hir::Generics<'tcx>, + trait_refs: hir::GenericBounds<'tcx>, + methods: &'tcx [hir::TraitItemRef], + ) { + let name = item.ident.to_string(); + let qualname = format!("::{}", self.tcx.def_path_str(item.def_id.to_def_id())); + let mut val = name.clone(); + if !generics.params.is_empty() { + val.push_str(&generic_params_to_string(generics.params)); + } + if !trait_refs.is_empty() { + val.push_str(": "); + val.push_str(&bounds_to_string(trait_refs)); + } + if !self.span.filter_generated(item.ident.span) { + let id = id_from_def_id(item.def_id.to_def_id()); + let span = self.span_from_span(item.ident.span); + let children = + methods.iter().map(|i| id_from_def_id(i.id.def_id.to_def_id())).collect(); + let attrs = self.tcx.hir().attrs(item.hir_id()); + self.dumper.dump_def( + &access_from!(self.save_ctxt, item.def_id), + Def { + kind: DefKind::Trait, + id, + span, + name, + qualname: qualname.clone(), + value: val, + parent: None, + children, + decl_id: None, + docs: self.save_ctxt.docs_for_attrs(attrs), + sig: sig::item_signature(item, &self.save_ctxt), + attributes: lower_attributes(attrs.to_vec(), &self.save_ctxt), + }, + ); + } + + // supertraits + for super_bound in trait_refs.iter() { + let (def_id, sub_span) = match *super_bound { + hir::GenericBound::Trait(ref trait_ref, _) => ( + self.lookup_def_id(trait_ref.trait_ref.hir_ref_id), + trait_ref.trait_ref.path.segments.last().unwrap().ident.span, + ), + hir::GenericBound::LangItemTrait(lang_item, span, _, _) => { + (Some(self.tcx.require_lang_item(lang_item, Some(span))), span) + } + hir::GenericBound::Outlives(..) => continue, + }; + + if let Some(id) = def_id { + if !self.span.filter_generated(sub_span) { + let span = self.span_from_span(sub_span); + self.dumper.dump_ref(Ref { + kind: RefKind::Type, + span: span.clone(), + ref_id: id_from_def_id(id), + }); + + self.dumper.dump_relation(Relation { + kind: RelationKind::SuperTrait, + span, + from: id_from_def_id(id), + to: id_from_def_id(item.def_id.to_def_id()), + }); + } + } + } + + // walk generics and methods + self.process_generic_params(generics, &qualname, item.hir_id()); + for method in methods { + let map = self.tcx.hir(); + self.process_trait_item(map.trait_item(method.id), item.def_id.to_def_id()) + } + } + + // `item` is the module in question, represented as an( item. + fn process_mod(&mut self, item: &'tcx hir::Item<'tcx>) { + if let Some(mod_data) = self.save_ctxt.get_item_data(item) { + down_cast_data!(mod_data, DefData, item.span); + self.dumper.dump_def(&access_from!(self.save_ctxt, item.def_id), mod_data); + } + } + + fn dump_path_ref(&mut self, id: hir::HirId, path: &hir::QPath<'tcx>) { + let path_data = self.save_ctxt.get_path_data(id, path); + if let Some(path_data) = path_data { + self.dumper.dump_ref(path_data); + } + } + + fn dump_path_segment_ref(&mut self, id: hir::HirId, segment: &hir::PathSegment<'tcx>) { + let segment_data = self.save_ctxt.get_path_segment_data_with_id(segment, id); + if let Some(segment_data) = segment_data { + self.dumper.dump_ref(segment_data); + } + } + + fn process_path(&mut self, id: hir::HirId, path: &hir::QPath<'tcx>) { + if self.span.filter_generated(path.span()) { + return; + } + self.dump_path_ref(id, path); + + // Type arguments + let segments = match path { + hir::QPath::Resolved(ty, path) => { + if let Some(ty) = ty { + self.visit_ty(ty); + } + path.segments + } + hir::QPath::TypeRelative(ty, segment) => { + self.visit_ty(ty); + std::slice::from_ref(*segment) + } + hir::QPath::LangItem(..) => return, + }; + for seg in segments { + if let Some(ref generic_args) = seg.args { + for arg in generic_args.args { + if let hir::GenericArg::Type(ref ty) = arg { + self.visit_ty(ty); + } + } + } + } + + if let hir::QPath::Resolved(_, path) = path { + self.write_sub_paths_truncated(path); + } + } + + fn process_struct_lit( + &mut self, + ex: &'tcx hir::Expr<'tcx>, + path: &'tcx hir::QPath<'tcx>, + fields: &'tcx [hir::ExprField<'tcx>], + variant: &'tcx ty::VariantDef, + rest: Option<&'tcx hir::Expr<'tcx>>, + ) { + if let Some(_ex_res_data) = self.save_ctxt.get_expr_data(ex) { + if let hir::QPath::Resolved(_, path) = path { + self.write_sub_paths_truncated(path); + } + // For MyEnum::MyVariant, get_expr_data gives us MyEnum, not MyVariant. + // For recording the span's ref id, we want MyVariant. + if !generated_code(ex.span) { + let sub_span = path.last_segment_span(); + let span = self.save_ctxt.span_from_span(sub_span); + let reff = + Ref { kind: RefKind::Type, span, ref_id: id_from_def_id(variant.def_id) }; + self.dumper.dump_ref(reff); + } + + for field in fields { + if let Some(field_data) = self.save_ctxt.get_field_ref_data(field, variant) { + self.dumper.dump_ref(field_data); + } + + self.visit_expr(&field.expr) + } + } + + if let Some(base) = rest { + self.visit_expr(&base); + } + } + + fn process_method_call( + &mut self, + ex: &'tcx hir::Expr<'tcx>, + seg: &'tcx hir::PathSegment<'tcx>, + args: &'tcx [hir::Expr<'tcx>], + ) { + debug!("process_method_call {:?} {:?}", ex, ex.span); + if let Some(mcd) = self.save_ctxt.get_expr_data(ex) { + down_cast_data!(mcd, RefData, ex.span); + if !generated_code(ex.span) { + self.dumper.dump_ref(mcd); + } + } + + // Explicit types in the turbo-fish. + if let Some(generic_args) = seg.args { + for arg in generic_args.args { + if let hir::GenericArg::Type(ty) = arg { + self.visit_ty(&ty) + }; + } + } + + // walk receiver and args + walk_list!(self, visit_expr, args); + } + + fn process_pat(&mut self, p: &'tcx hir::Pat<'tcx>) { + match p.kind { + hir::PatKind::Struct(ref _path, fields, _) => { + // FIXME do something with _path? + let adt = match self.save_ctxt.typeck_results().node_type_opt(p.hir_id) { + Some(ty) if ty.ty_adt_def().is_some() => ty.ty_adt_def().unwrap(), + _ => { + intravisit::walk_pat(self, p); + return; + } + }; + let variant = adt.variant_of_res(self.save_ctxt.get_path_res(p.hir_id)); + + for field in fields { + if let Some(index) = self.tcx.find_field_index(field.ident, variant) { + if !self.span.filter_generated(field.ident.span) { + let span = self.span_from_span(field.ident.span); + self.dumper.dump_ref(Ref { + kind: RefKind::Variable, + span, + ref_id: id_from_def_id(variant.fields[index].did), + }); + } + } + self.visit_pat(&field.pat); + } + } + _ => intravisit::walk_pat(self, p), + } + } + + fn process_var_decl(&mut self, pat: &'tcx hir::Pat<'tcx>) { + // The pattern could declare multiple new vars, + // we must walk the pattern and collect them all. + let mut collector = PathCollector::new(self.tcx); + collector.visit_pat(&pat); + self.visit_pat(&pat); + + // Process collected paths. + for (id, ident, _) in collector.collected_idents { + let res = self.save_ctxt.get_path_res(id); + match res { + Res::Local(hir_id) => { + let typ = self + .save_ctxt + .typeck_results() + .node_type_opt(hir_id) + .map(|t| t.to_string()) + .unwrap_or_default(); + + // Rust uses the id of the pattern for var lookups, so we'll use it too. + if !self.span.filter_generated(ident.span) { + let qualname = format!("{}${}", ident, hir_id); + let id = id_from_hir_id(hir_id, &self.save_ctxt); + let span = self.span_from_span(ident.span); + + self.dumper.dump_def( + &Access { public: false, reachable: false }, + Def { + kind: DefKind::Local, + id, + span, + name: ident.to_string(), + qualname, + value: typ, + parent: None, + children: vec![], + decl_id: None, + docs: String::new(), + sig: None, + attributes: vec![], + }, + ); + } + } + Res::Def( + HirDefKind::Ctor(..) + | HirDefKind::Const + | HirDefKind::AssocConst + | HirDefKind::Struct + | HirDefKind::Variant + | HirDefKind::TyAlias + | HirDefKind::AssocTy, + _, + ) + | Res::SelfTy { .. } => { + self.dump_path_segment_ref(id, &hir::PathSegment::from_ident(ident)); + } + def => { + error!("unexpected definition kind when processing collected idents: {:?}", def) + } + } + } + + for (id, ref path) in collector.collected_paths { + self.process_path(id, path); + } + } + + /// Extracts macro use and definition information from the AST node defined + /// by the given NodeId, using the expansion information from the node's + /// span. + /// + /// If the span is not macro-generated, do nothing, else use callee and + /// callsite spans to record macro definition and use data, using the + /// mac_uses and mac_defs sets to prevent multiples. + fn process_macro_use(&mut self, _span: Span) { + // FIXME if we're not dumping the defs (see below), there is no point + // dumping refs either. + // let source_span = span.source_callsite(); + // if !self.macro_calls.insert(source_span) { + // return; + // } + + // let data = match self.save_ctxt.get_macro_use_data(span) { + // None => return, + // Some(data) => data, + // }; + + // self.dumper.macro_use(data); + + // FIXME write the macro def + // let mut hasher = DefaultHasher::new(); + // data.callee_span.hash(&mut hasher); + // let hash = hasher.finish(); + // let qualname = format!("{}::{}", data.name, hash); + // Don't write macro definition for imported macros + // if !self.mac_defs.contains(&data.callee_span) + // && !data.imported { + // self.mac_defs.insert(data.callee_span); + // if let Some(sub_span) = self.span.span_for_macro_def_name(data.callee_span) { + // self.dumper.macro_data(MacroData { + // span: sub_span, + // name: data.name.clone(), + // qualname: qualname.clone(), + // // FIXME where do macro docs come from? + // docs: String::new(), + // }.lower(self.tcx)); + // } + // } + } + + fn process_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>, trait_id: DefId) { + self.process_macro_use(trait_item.span); + match trait_item.kind { + hir::TraitItemKind::Const(ref ty, body) => { + let body = body.map(|b| &self.tcx.hir().body(b).value); + let attrs = self.tcx.hir().attrs(trait_item.hir_id()); + self.process_assoc_const( + trait_item.def_id, + trait_item.ident, + &ty, + body, + trait_id, + attrs, + ); + } + hir::TraitItemKind::Fn(ref sig, ref trait_fn) => { + let body = + if let hir::TraitFn::Provided(body) = trait_fn { Some(*body) } else { None }; + self.process_method( + sig, + body, + trait_item.def_id, + trait_item.ident, + &trait_item.generics, + trait_item.span, + ); + } + hir::TraitItemKind::Type(ref bounds, ref default_ty) => { + // FIXME do something with _bounds (for type refs) + let name = trait_item.ident.name.to_string(); + let qualname = + format!("::{}", self.tcx.def_path_str(trait_item.def_id.to_def_id())); + + if !self.span.filter_generated(trait_item.ident.span) { + let span = self.span_from_span(trait_item.ident.span); + let id = id_from_def_id(trait_item.def_id.to_def_id()); + let attrs = self.tcx.hir().attrs(trait_item.hir_id()); + + self.dumper.dump_def( + &Access { public: true, reachable: true }, + Def { + kind: DefKind::Type, + id, + span, + name, + qualname, + value: self.span.snippet(trait_item.span), + parent: Some(id_from_def_id(trait_id)), + children: vec![], + decl_id: None, + docs: self.save_ctxt.docs_for_attrs(attrs), + sig: sig::assoc_type_signature( + trait_item.hir_id(), + trait_item.ident, + Some(bounds), + default_ty.as_ref().map(|ty| &**ty), + &self.save_ctxt, + ), + attributes: lower_attributes(attrs.to_vec(), &self.save_ctxt), + }, + ); + } + + if let Some(default_ty) = default_ty { + self.visit_ty(default_ty) + } + } + } + } + + fn process_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>, impl_id: DefId) { + self.process_macro_use(impl_item.span); + match impl_item.kind { + hir::ImplItemKind::Const(ref ty, body) => { + let body = self.tcx.hir().body(body); + let attrs = self.tcx.hir().attrs(impl_item.hir_id()); + self.process_assoc_const( + impl_item.def_id, + impl_item.ident, + &ty, + Some(&body.value), + impl_id, + attrs, + ); + } + hir::ImplItemKind::Fn(ref sig, body) => { + self.process_method( + sig, + Some(body), + impl_item.def_id, + impl_item.ident, + &impl_item.generics, + impl_item.span, + ); + } + hir::ImplItemKind::TyAlias(ref ty) => { + // FIXME: uses of the assoc type should ideally point to this + // 'def' and the name here should be a ref to the def in the + // trait. + self.visit_ty(ty) + } + } + } + + pub(crate) fn process_crate(&mut self) { + let id = hir::CRATE_HIR_ID; + let qualname = + format!("::{}", self.tcx.def_path_str(self.tcx.hir().local_def_id(id).to_def_id())); + + let sm = self.tcx.sess.source_map(); + let krate_mod = self.tcx.hir().root_module(); + let filename = sm.span_to_filename(krate_mod.spans.inner_span); + let data_id = id_from_hir_id(id, &self.save_ctxt); + let children = + krate_mod.item_ids.iter().map(|i| id_from_def_id(i.def_id.to_def_id())).collect(); + let span = self.span_from_span(krate_mod.spans.inner_span); + let attrs = self.tcx.hir().attrs(id); + + self.dumper.dump_def( + &Access { public: true, reachable: true }, + Def { + kind: DefKind::Mod, + id: data_id, + name: String::new(), + qualname, + span, + value: filename.prefer_remapped().to_string(), + children, + parent: None, + decl_id: None, + docs: self.save_ctxt.docs_for_attrs(attrs), + sig: None, + attributes: lower_attributes(attrs.to_owned(), &self.save_ctxt), + }, + ); + self.tcx.hir().walk_toplevel_module(self); + } + + fn process_bounds(&mut self, bounds: hir::GenericBounds<'tcx>) { + for bound in bounds { + if let hir::GenericBound::Trait(ref trait_ref, _) = *bound { + self.process_path( + trait_ref.trait_ref.hir_ref_id, + &hir::QPath::Resolved(None, &trait_ref.trait_ref.path), + ) + } + } + } +} + +impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx> { + type NestedFilter = nested_filter::All; + + fn nested_visit_map(&mut self) -> Self::Map { + self.tcx.hir() + } + + fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { + self.process_macro_use(item.span); + match item.kind { + hir::ItemKind::Use(path, hir::UseKind::Single) => { + let sub_span = path.segments.last().unwrap().ident.span; + if !self.span.filter_generated(sub_span) { + let access = access_from!(self.save_ctxt, item.def_id); + let ref_id = self.lookup_def_id(item.hir_id()).map(id_from_def_id); + let span = self.span_from_span(sub_span); + let parent = self.save_ctxt.tcx.local_parent(item.def_id); + self.dumper.import( + &access, + Import { + kind: ImportKind::Use, + ref_id, + span, + alias_span: None, + name: item.ident.to_string(), + value: String::new(), + parent: Some(id_from_def_id(parent.to_def_id())), + }, + ); + self.write_sub_paths_truncated(&path); + } + } + hir::ItemKind::Use(path, hir::UseKind::Glob) => { + // Make a comma-separated list of names of imported modules. + let names = self.tcx.names_imported_by_glob_use(item.def_id); + let names: Vec<_> = names.iter().map(|n| n.to_string()).collect(); + + // Otherwise it's a span with wrong macro expansion info, which + // we don't want to track anyway, since it's probably macro-internal `use` + if let Some(sub_span) = self.span.sub_span_of_star(item.span) { + if !self.span.filter_generated(item.span) { + let access = access_from!(self.save_ctxt, item.def_id); + let span = self.span_from_span(sub_span); + let parent = self.save_ctxt.tcx.local_parent(item.def_id); + self.dumper.import( + &access, + Import { + kind: ImportKind::GlobUse, + ref_id: None, + span, + alias_span: None, + name: "*".to_owned(), + value: names.join(", "), + parent: Some(id_from_def_id(parent.to_def_id())), + }, + ); + self.write_sub_paths(&path); + } + } + } + hir::ItemKind::ExternCrate(_) => { + let name_span = item.ident.span; + if !self.span.filter_generated(name_span) { + let span = self.span_from_span(name_span); + let parent = self.save_ctxt.tcx.local_parent(item.def_id); + self.dumper.import( + &Access { public: false, reachable: false }, + Import { + kind: ImportKind::ExternCrate, + ref_id: None, + span, + alias_span: None, + name: item.ident.to_string(), + value: String::new(), + parent: Some(id_from_def_id(parent.to_def_id())), + }, + ); + } + } + hir::ItemKind::Fn(ref sig, ref ty_params, body) => { + self.process_fn(item, sig.decl, &sig.header, ty_params, body) + } + hir::ItemKind::Static(ref typ, _, body) => { + let body = self.tcx.hir().body(body); + self.process_static_or_const_item(item, typ, &body.value) + } + hir::ItemKind::Const(ref typ, body) => { + let body = self.tcx.hir().body(body); + self.process_static_or_const_item(item, typ, &body.value) + } + hir::ItemKind::Struct(ref def, ref ty_params) + | hir::ItemKind::Union(ref def, ref ty_params) => { + self.process_struct(item, def, ty_params) + } + hir::ItemKind::Enum(ref def, ref ty_params) => self.process_enum(item, def, ty_params), + hir::ItemKind::Impl(ref impl_) => self.process_impl(item, impl_), + hir::ItemKind::Trait(_, _, ref generics, ref trait_refs, methods) => { + self.process_trait(item, generics, trait_refs, methods) + } + hir::ItemKind::Mod(ref m) => { + self.process_mod(item); + intravisit::walk_mod(self, m, item.hir_id()); + } + hir::ItemKind::TyAlias(ty, ref generics) => { + let qualname = format!("::{}", self.tcx.def_path_str(item.def_id.to_def_id())); + let value = ty_to_string(&ty); + if !self.span.filter_generated(item.ident.span) { + let span = self.span_from_span(item.ident.span); + let id = id_from_def_id(item.def_id.to_def_id()); + let attrs = self.tcx.hir().attrs(item.hir_id()); + + self.dumper.dump_def( + &access_from!(self.save_ctxt, item.def_id), + Def { + kind: DefKind::Type, + id, + span, + name: item.ident.to_string(), + qualname: qualname.clone(), + value, + parent: None, + children: vec![], + decl_id: None, + docs: self.save_ctxt.docs_for_attrs(attrs), + sig: sig::item_signature(item, &self.save_ctxt), + attributes: lower_attributes(attrs.to_vec(), &self.save_ctxt), + }, + ); + } + + self.visit_ty(ty); + self.process_generic_params(generics, &qualname, item.hir_id()); + } + _ => intravisit::walk_item(self, item), + } + } + + fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) { + for param in generics.params { + match param.kind { + hir::GenericParamKind::Lifetime { .. } => {} + hir::GenericParamKind::Type { ref default, .. } => { + if let Some(ref ty) = default { + self.visit_ty(ty); + } + } + hir::GenericParamKind::Const { ref ty, ref default } => { + self.visit_ty(ty); + if let Some(default) = default { + self.visit_anon_const(default); + } + } + } + } + for pred in generics.predicates { + if let hir::WherePredicate::BoundPredicate(ref wbp) = *pred { + self.process_bounds(wbp.bounds); + self.visit_ty(wbp.bounded_ty); + } + } + } + + fn visit_ty(&mut self, t: &'tcx hir::Ty<'tcx>) { + self.process_macro_use(t.span); + match t.kind { + hir::TyKind::Path(ref path) => { + if generated_code(t.span) { + return; + } + + if let Some(id) = self.lookup_def_id(t.hir_id) { + let sub_span = path.last_segment_span(); + let span = self.span_from_span(sub_span); + self.dumper.dump_ref(Ref { + kind: RefKind::Type, + span, + ref_id: id_from_def_id(id), + }); + } + + if let hir::QPath::Resolved(_, path) = path { + self.write_sub_paths_truncated(path); + } + intravisit::walk_qpath(self, path, t.hir_id, t.span); + } + hir::TyKind::Array(ref ty, ref length) => { + self.visit_ty(ty); + let map = self.tcx.hir(); + match length { + // FIXME(generic_arg_infer): We probably want to + // output the inferred type here? :shrug: + hir::ArrayLen::Infer(..) => {} + hir::ArrayLen::Body(anon_const) => self + .nest_typeck_results(self.tcx.hir().local_def_id(anon_const.hir_id), |v| { + v.visit_expr(&map.body(anon_const.body).value) + }), + } + } + hir::TyKind::OpaqueDef(item_id, _) => { + let item = self.tcx.hir().item(item_id); + self.nest_typeck_results(item_id.def_id, |v| v.visit_item(item)); + } + _ => intravisit::walk_ty(self, t), + } + } + + fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) { + debug!("visit_expr {:?}", ex.kind); + self.process_macro_use(ex.span); + match ex.kind { + hir::ExprKind::Struct(ref path, ref fields, ref rest) => { + let hir_expr = self.save_ctxt.tcx.hir().expect_expr(ex.hir_id); + let adt = match self.save_ctxt.typeck_results().expr_ty_opt(&hir_expr) { + Some(ty) if ty.ty_adt_def().is_some() => ty.ty_adt_def().unwrap(), + _ => { + intravisit::walk_expr(self, ex); + return; + } + }; + let res = self.save_ctxt.get_path_res(hir_expr.hir_id); + self.process_struct_lit(ex, path, fields, adt.variant_of_res(res), *rest) + } + hir::ExprKind::MethodCall(ref seg, args, _) => self.process_method_call(ex, seg, args), + hir::ExprKind::Field(ref sub_ex, _) => { + self.visit_expr(&sub_ex); + + if let Some(field_data) = self.save_ctxt.get_expr_data(ex) { + down_cast_data!(field_data, RefData, ex.span); + if !generated_code(ex.span) { + self.dumper.dump_ref(field_data); + } + } + } + hir::ExprKind::Closure(&hir::Closure { ref fn_decl, body, .. }) => { + let id = format!("${}", ex.hir_id); + + // walk arg and return types + for ty in fn_decl.inputs { + self.visit_ty(ty); + } + + if let hir::FnRetTy::Return(ref ret_ty) = fn_decl.output { + self.visit_ty(ret_ty); + } + + // walk the body + let map = self.tcx.hir(); + self.nest_typeck_results(self.tcx.hir().local_def_id(ex.hir_id), |v| { + let body = map.body(body); + v.process_formals(body.params, &id); + v.visit_expr(&body.value) + }); + } + hir::ExprKind::Repeat(ref expr, ref length) => { + self.visit_expr(expr); + let map = self.tcx.hir(); + match length { + // FIXME(generic_arg_infer): We probably want to + // output the inferred type here? :shrug: + hir::ArrayLen::Infer(..) => {} + hir::ArrayLen::Body(anon_const) => self + .nest_typeck_results(self.tcx.hir().local_def_id(anon_const.hir_id), |v| { + v.visit_expr(&map.body(anon_const.body).value) + }), + } + } + // In particular, we take this branch for call and path expressions, + // where we'll index the idents involved just by continuing to walk. + _ => intravisit::walk_expr(self, ex), + } + } + + fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) { + self.process_macro_use(p.span); + self.process_pat(p); + } + + fn visit_arm(&mut self, arm: &'tcx hir::Arm<'tcx>) { + self.process_var_decl(&arm.pat); + if let Some(hir::Guard::If(expr)) = &arm.guard { + self.visit_expr(expr); + } + self.visit_expr(&arm.body); + } + + fn visit_qpath(&mut self, path: &'tcx hir::QPath<'tcx>, id: hir::HirId, _: Span) { + self.process_path(id, path); + } + + fn visit_stmt(&mut self, s: &'tcx hir::Stmt<'tcx>) { + self.process_macro_use(s.span); + intravisit::walk_stmt(self, s) + } + + fn visit_local(&mut self, l: &'tcx hir::Local<'tcx>) { + self.process_macro_use(l.span); + self.process_var_decl(&l.pat); + + // Just walk the initializer, the else branch and type (don't want to walk the pattern again). + walk_list!(self, visit_ty, &l.ty); + walk_list!(self, visit_expr, &l.init); + walk_list!(self, visit_block, l.els); + } + + fn visit_foreign_item(&mut self, item: &'tcx hir::ForeignItem<'tcx>) { + let access = access_from!(self.save_ctxt, item.def_id); + + match item.kind { + hir::ForeignItemKind::Fn(decl, _, ref generics) => { + if let Some(fn_data) = self.save_ctxt.get_extern_item_data(item) { + down_cast_data!(fn_data, DefData, item.span); + + self.process_generic_params(generics, &fn_data.qualname, item.hir_id()); + self.dumper.dump_def(&access, fn_data); + } + + for ty in decl.inputs { + self.visit_ty(ty); + } + + if let hir::FnRetTy::Return(ref ret_ty) = decl.output { + self.visit_ty(ret_ty); + } + } + hir::ForeignItemKind::Static(ref ty, _) => { + if let Some(var_data) = self.save_ctxt.get_extern_item_data(item) { + down_cast_data!(var_data, DefData, item.span); + self.dumper.dump_def(&access, var_data); + } + + self.visit_ty(ty); + } + hir::ForeignItemKind::Type => { + if let Some(var_data) = self.save_ctxt.get_extern_item_data(item) { + down_cast_data!(var_data, DefData, item.span); + self.dumper.dump_def(&access, var_data); + } + } + } + } +} diff --git a/compiler/rustc_save_analysis/src/dumper.rs b/compiler/rustc_save_analysis/src/dumper.rs new file mode 100644 index 000000000..5a2628287 --- /dev/null +++ b/compiler/rustc_save_analysis/src/dumper.rs @@ -0,0 +1,91 @@ +use rls_data::config::Config; +use rls_data::{ + self, Analysis, CompilationOptions, CratePreludeData, Def, DefKind, Impl, Import, MacroRef, + Ref, RefKind, Relation, +}; +use rls_span::{Column, Row}; + +#[derive(Debug)] +pub struct Access { + pub reachable: bool, + pub public: bool, +} + +pub struct Dumper { + result: Analysis, + config: Config, +} + +impl Dumper { + pub fn new(config: Config) -> Dumper { + Dumper { config: config.clone(), result: Analysis::new(config) } + } + + pub fn analysis(&self) -> &Analysis { + &self.result + } +} + +impl Dumper { + pub fn crate_prelude(&mut self, data: CratePreludeData) { + self.result.prelude = Some(data) + } + + pub fn compilation_opts(&mut self, data: CompilationOptions) { + self.result.compilation = Some(data); + } + + pub fn _macro_use(&mut self, data: MacroRef) { + if self.config.pub_only || self.config.reachable_only { + return; + } + self.result.macro_refs.push(data); + } + + pub fn import(&mut self, access: &Access, import: Import) { + if !access.public && self.config.pub_only || !access.reachable && self.config.reachable_only + { + return; + } + self.result.imports.push(import); + } + + pub fn dump_ref(&mut self, data: Ref) { + if self.config.pub_only || self.config.reachable_only { + return; + } + self.result.refs.push(data); + } + + pub fn dump_def(&mut self, access: &Access, mut data: Def) { + if !access.public && self.config.pub_only || !access.reachable && self.config.reachable_only + { + return; + } + if data.kind == DefKind::Mod && data.span.file_name.to_str().unwrap() != data.value { + // If the module is an out-of-line definition, then we'll make the + // definition the first character in the module's file and turn + // the declaration into a reference to it. + let rf = Ref { kind: RefKind::Mod, span: data.span, ref_id: data.id }; + self.result.refs.push(rf); + data.span = rls_data::SpanData { + file_name: data.value.clone().into(), + byte_start: 0, + byte_end: 0, + line_start: Row::new_one_indexed(1), + line_end: Row::new_one_indexed(1), + column_start: Column::new_one_indexed(1), + column_end: Column::new_one_indexed(1), + } + } + self.result.defs.push(data); + } + + pub fn dump_relation(&mut self, data: Relation) { + self.result.relations.push(data); + } + + pub fn dump_impl(&mut self, data: Impl) { + self.result.impls.push(data); + } +} diff --git a/compiler/rustc_save_analysis/src/lib.rs b/compiler/rustc_save_analysis/src/lib.rs new file mode 100644 index 000000000..a1a2040bb --- /dev/null +++ b/compiler/rustc_save_analysis/src/lib.rs @@ -0,0 +1,1075 @@ +#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")] +#![feature(if_let_guard)] +#![feature(let_else)] +#![recursion_limit = "256"] +#![allow(rustc::potential_query_instability)] + +mod dump_visitor; +mod dumper; +#[macro_use] +mod span_utils; +mod sig; + +use rustc_ast as ast; +use rustc_ast::util::comments::beautify_doc_string; +use rustc_ast_pretty::pprust::attribute_to_string; +use rustc_hir as hir; +use rustc_hir::def::{DefKind as HirDefKind, Res}; +use rustc_hir::def_id::{DefId, LOCAL_CRATE}; +use rustc_hir::intravisit::{self, Visitor}; +use rustc_hir::Node; +use rustc_hir_pretty::{enum_def_to_string, fn_to_string, ty_to_string}; +use rustc_middle::hir::nested_filter; +use rustc_middle::middle::privacy::AccessLevels; +use rustc_middle::ty::{self, print::with_no_trimmed_paths, DefIdTree, TyCtxt}; +use rustc_middle::{bug, span_bug}; +use rustc_session::config::{CrateType, Input, OutputType}; +use rustc_session::cstore::ExternCrate; +use rustc_session::output::{filename_for_metadata, out_filename}; +use rustc_span::symbol::Ident; +use rustc_span::*; + +use std::cell::Cell; +use std::default::Default; +use std::env; +use std::fs::File; +use std::io::BufWriter; +use std::path::{Path, PathBuf}; + +use dump_visitor::DumpVisitor; +use span_utils::SpanUtils; + +use rls_data::config::Config; +use rls_data::{ + Analysis, Def, DefKind, ExternalCrateData, GlobalCrateId, Impl, ImplKind, MacroRef, Ref, + RefKind, Relation, RelationKind, SpanData, +}; + +use tracing::{debug, error, info}; + +pub struct SaveContext<'tcx> { + tcx: TyCtxt<'tcx>, + maybe_typeck_results: Option<&'tcx ty::TypeckResults<'tcx>>, + access_levels: &'tcx AccessLevels, + span_utils: SpanUtils<'tcx>, + config: Config, + impl_counter: Cell<u32>, +} + +#[derive(Debug)] +pub enum Data { + RefData(Ref), + DefData(Def), + RelationData(Relation, Impl), +} + +impl<'tcx> SaveContext<'tcx> { + /// Gets the type-checking results for the current body. + /// As this will ICE if called outside bodies, only call when working with + /// `Expr` or `Pat` nodes (they are guaranteed to be found only in bodies). + #[track_caller] + fn typeck_results(&self) -> &'tcx ty::TypeckResults<'tcx> { + self.maybe_typeck_results.expect("`SaveContext::typeck_results` called outside of body") + } + + fn span_from_span(&self, span: Span) -> SpanData { + use rls_span::{Column, Row}; + + let sm = self.tcx.sess.source_map(); + let start = sm.lookup_char_pos(span.lo()); + let end = sm.lookup_char_pos(span.hi()); + + SpanData { + file_name: start.file.name.prefer_remapped().to_string().into(), + byte_start: span.lo().0, + byte_end: span.hi().0, + line_start: Row::new_one_indexed(start.line as u32), + line_end: Row::new_one_indexed(end.line as u32), + column_start: Column::new_one_indexed(start.col.0 as u32 + 1), + column_end: Column::new_one_indexed(end.col.0 as u32 + 1), + } + } + + // Returns path to the compilation output (e.g., libfoo-12345678.rmeta) + pub fn compilation_output(&self, crate_name: &str) -> PathBuf { + let sess = &self.tcx.sess; + // Save-analysis is emitted per whole session, not per each crate type + let crate_type = sess.crate_types()[0]; + let outputs = &*self.tcx.output_filenames(()); + + if outputs.outputs.contains_key(&OutputType::Metadata) { + filename_for_metadata(sess, crate_name, outputs) + } else if outputs.outputs.should_codegen() { + out_filename(sess, crate_type, outputs, crate_name) + } else { + // Otherwise it's only a DepInfo, in which case we return early and + // not even reach the analysis stage. + unreachable!() + } + } + + // List external crates used by the current crate. + pub fn get_external_crates(&self) -> Vec<ExternalCrateData> { + let mut result = Vec::with_capacity(self.tcx.crates(()).len()); + + for &n in self.tcx.crates(()).iter() { + let Some(&ExternCrate { span, .. }) = self.tcx.extern_crate(n.as_def_id()) else { + debug!("skipping crate {}, no data", n); + continue; + }; + let lo_loc = self.span_utils.sess.source_map().lookup_char_pos(span.lo()); + result.push(ExternalCrateData { + // FIXME: change file_name field to PathBuf in rls-data + // https://github.com/nrc/rls-data/issues/7 + file_name: self.span_utils.make_filename_string(&lo_loc.file), + num: n.as_u32(), + id: GlobalCrateId { + name: self.tcx.crate_name(n).to_string(), + disambiguator: ( + self.tcx.def_path_hash(n.as_def_id()).stable_crate_id().to_u64(), + 0, + ), + }, + }); + } + + result + } + + pub fn get_extern_item_data(&self, item: &hir::ForeignItem<'_>) -> Option<Data> { + let def_id = item.def_id.to_def_id(); + let qualname = format!("::{}", self.tcx.def_path_str(def_id)); + let attrs = self.tcx.hir().attrs(item.hir_id()); + match item.kind { + hir::ForeignItemKind::Fn(ref decl, arg_names, ref generics) => { + filter!(self.span_utils, item.ident.span); + + Some(Data::DefData(Def { + kind: DefKind::ForeignFunction, + id: id_from_def_id(def_id), + span: self.span_from_span(item.ident.span), + name: item.ident.to_string(), + qualname, + value: fn_to_string( + decl, + hir::FnHeader { + // functions in extern block are implicitly unsafe + unsafety: hir::Unsafety::Unsafe, + // functions in extern block cannot be const + constness: hir::Constness::NotConst, + abi: self.tcx.hir().get_foreign_abi(item.hir_id()), + // functions in extern block cannot be async + asyncness: hir::IsAsync::NotAsync, + }, + Some(item.ident.name), + generics, + arg_names, + None, + ), + parent: None, + children: vec![], + decl_id: None, + docs: self.docs_for_attrs(attrs), + sig: sig::foreign_item_signature(item, self), + attributes: lower_attributes(attrs.to_vec(), self), + })) + } + hir::ForeignItemKind::Static(ref ty, _) => { + filter!(self.span_utils, item.ident.span); + + let id = id_from_def_id(def_id); + let span = self.span_from_span(item.ident.span); + + Some(Data::DefData(Def { + kind: DefKind::ForeignStatic, + id, + span, + name: item.ident.to_string(), + qualname, + value: ty_to_string(ty), + parent: None, + children: vec![], + decl_id: None, + docs: self.docs_for_attrs(attrs), + sig: sig::foreign_item_signature(item, self), + attributes: lower_attributes(attrs.to_vec(), self), + })) + } + // FIXME(plietar): needs a new DefKind in rls-data + hir::ForeignItemKind::Type => None, + } + } + + pub fn get_item_data(&self, item: &hir::Item<'_>) -> Option<Data> { + let def_id = item.def_id.to_def_id(); + let attrs = self.tcx.hir().attrs(item.hir_id()); + match item.kind { + hir::ItemKind::Fn(ref sig, ref generics, _) => { + let qualname = format!("::{}", self.tcx.def_path_str(def_id)); + filter!(self.span_utils, item.ident.span); + Some(Data::DefData(Def { + kind: DefKind::Function, + id: id_from_def_id(def_id), + span: self.span_from_span(item.ident.span), + name: item.ident.to_string(), + qualname, + value: fn_to_string( + sig.decl, + sig.header, + Some(item.ident.name), + generics, + &[], + None, + ), + parent: None, + children: vec![], + decl_id: None, + docs: self.docs_for_attrs(attrs), + sig: sig::item_signature(item, self), + attributes: lower_attributes(attrs.to_vec(), self), + })) + } + hir::ItemKind::Static(ref typ, ..) => { + let qualname = format!("::{}", self.tcx.def_path_str(def_id)); + + filter!(self.span_utils, item.ident.span); + + let id = id_from_def_id(def_id); + let span = self.span_from_span(item.ident.span); + + Some(Data::DefData(Def { + kind: DefKind::Static, + id, + span, + name: item.ident.to_string(), + qualname, + value: ty_to_string(&typ), + parent: None, + children: vec![], + decl_id: None, + docs: self.docs_for_attrs(attrs), + sig: sig::item_signature(item, self), + attributes: lower_attributes(attrs.to_vec(), self), + })) + } + hir::ItemKind::Const(ref typ, _) => { + let qualname = format!("::{}", self.tcx.def_path_str(def_id)); + filter!(self.span_utils, item.ident.span); + + let id = id_from_def_id(def_id); + let span = self.span_from_span(item.ident.span); + + Some(Data::DefData(Def { + kind: DefKind::Const, + id, + span, + name: item.ident.to_string(), + qualname, + value: ty_to_string(typ), + parent: None, + children: vec![], + decl_id: None, + docs: self.docs_for_attrs(attrs), + sig: sig::item_signature(item, self), + attributes: lower_attributes(attrs.to_vec(), self), + })) + } + hir::ItemKind::Mod(ref m) => { + let qualname = format!("::{}", self.tcx.def_path_str(def_id)); + + let sm = self.tcx.sess.source_map(); + let filename = sm.span_to_filename(m.spans.inner_span); + + filter!(self.span_utils, item.ident.span); + + Some(Data::DefData(Def { + kind: DefKind::Mod, + id: id_from_def_id(def_id), + name: item.ident.to_string(), + qualname, + span: self.span_from_span(item.ident.span), + value: filename.prefer_remapped().to_string(), + parent: None, + children: m + .item_ids + .iter() + .map(|i| id_from_def_id(i.def_id.to_def_id())) + .collect(), + decl_id: None, + docs: self.docs_for_attrs(attrs), + sig: sig::item_signature(item, self), + attributes: lower_attributes(attrs.to_vec(), self), + })) + } + hir::ItemKind::Enum(ref def, ref generics) => { + let name = item.ident.to_string(); + let qualname = format!("::{}", self.tcx.def_path_str(def_id)); + filter!(self.span_utils, item.ident.span); + let value = + enum_def_to_string(def, generics, item.ident.name, item.span); + Some(Data::DefData(Def { + kind: DefKind::Enum, + id: id_from_def_id(def_id), + span: self.span_from_span(item.ident.span), + name, + qualname, + value, + parent: None, + children: def.variants.iter().map(|v| id_from_hir_id(v.id, self)).collect(), + decl_id: None, + docs: self.docs_for_attrs(attrs), + sig: sig::item_signature(item, self), + attributes: lower_attributes(attrs.to_vec(), self), + })) + } + hir::ItemKind::Impl(hir::Impl { ref of_trait, ref self_ty, ref items, .. }) + if let hir::TyKind::Path(hir::QPath::Resolved(_, ref path)) = self_ty.kind => + { + // Common case impl for a struct or something basic. + if generated_code(path.span) { + return None; + } + let sub_span = path.segments.last().unwrap().ident.span; + filter!(self.span_utils, sub_span); + + let impl_id = self.next_impl_id(); + let span = self.span_from_span(sub_span); + + let type_data = self.lookup_def_id(self_ty.hir_id); + type_data.map(|type_data| { + Data::RelationData( + Relation { + kind: RelationKind::Impl { id: impl_id }, + span: span.clone(), + from: id_from_def_id(type_data), + to: of_trait + .as_ref() + .and_then(|t| self.lookup_def_id(t.hir_ref_id)) + .map(id_from_def_id) + .unwrap_or_else(null_id), + }, + Impl { + id: impl_id, + kind: match *of_trait { + Some(_) => ImplKind::Direct, + None => ImplKind::Inherent, + }, + span, + value: String::new(), + parent: None, + children: items + .iter() + .map(|i| id_from_def_id(i.id.def_id.to_def_id())) + .collect(), + docs: String::new(), + sig: None, + attributes: vec![], + }, + ) + }) + } + hir::ItemKind::Impl(_) => None, + _ => { + // FIXME + bug!(); + } + } + } + + pub fn get_field_data(&self, field: &hir::FieldDef<'_>, scope: hir::HirId) -> Option<Def> { + let name = field.ident.to_string(); + let scope_def_id = self.tcx.hir().local_def_id(scope).to_def_id(); + let qualname = format!("::{}::{}", self.tcx.def_path_str(scope_def_id), field.ident); + filter!(self.span_utils, field.ident.span); + let field_def_id = self.tcx.hir().local_def_id(field.hir_id).to_def_id(); + let typ = self.tcx.type_of(field_def_id).to_string(); + + let id = id_from_def_id(field_def_id); + let span = self.span_from_span(field.ident.span); + let attrs = self.tcx.hir().attrs(field.hir_id); + + Some(Def { + kind: DefKind::Field, + id, + span, + name, + qualname, + value: typ, + parent: Some(id_from_def_id(scope_def_id)), + children: vec![], + decl_id: None, + docs: self.docs_for_attrs(attrs), + sig: sig::field_signature(field, self), + attributes: lower_attributes(attrs.to_vec(), self), + }) + } + + // FIXME would be nice to take a MethodItem here, but the ast provides both + // trait and impl flavours, so the caller must do the disassembly. + pub fn get_method_data(&self, hir_id: hir::HirId, ident: Ident, span: Span) -> Option<Def> { + // The qualname for a method is the trait name or name of the struct in an impl in + // which the method is declared in, followed by the method's name. + let def_id = self.tcx.hir().local_def_id(hir_id).to_def_id(); + let (qualname, parent_scope, decl_id, docs, attributes) = + match self.tcx.impl_of_method(def_id) { + Some(impl_id) => match self.tcx.hir().get_if_local(impl_id) { + Some(Node::Item(item)) => match item.kind { + hir::ItemKind::Impl(hir::Impl { ref self_ty, .. }) => { + let hir = self.tcx.hir(); + + let mut qualname = String::from("<"); + qualname + .push_str(&rustc_hir_pretty::id_to_string(&hir, self_ty.hir_id)); + + let trait_id = self.tcx.trait_id_of_impl(impl_id); + let mut docs = String::new(); + let mut attrs = vec![]; + if let Some(Node::ImplItem(_)) = hir.find(hir_id) { + attrs = self.tcx.hir().attrs(hir_id).to_vec(); + docs = self.docs_for_attrs(&attrs); + } + + let mut decl_id = None; + if let Some(def_id) = trait_id { + // A method in a trait impl. + qualname.push_str(" as "); + qualname.push_str(&self.tcx.def_path_str(def_id)); + + decl_id = self + .tcx + .associated_items(def_id) + .filter_by_name_unhygienic(ident.name) + .next() + .map(|item| item.def_id); + } + qualname.push('>'); + + (qualname, trait_id, decl_id, docs, attrs) + } + _ => { + span_bug!( + span, + "Container {:?} for method {} not an impl?", + impl_id, + hir_id + ); + } + }, + r => { + span_bug!( + span, + "Container {:?} for method {} is not a node item {:?}", + impl_id, + hir_id, + r + ); + } + }, + None => match self.tcx.trait_of_item(def_id) { + Some(def_id) => { + let mut docs = String::new(); + let mut attrs = vec![]; + + if let Some(Node::TraitItem(_)) = self.tcx.hir().find(hir_id) { + attrs = self.tcx.hir().attrs(hir_id).to_vec(); + docs = self.docs_for_attrs(&attrs); + } + + ( + format!("::{}", self.tcx.def_path_str(def_id)), + Some(def_id), + None, + docs, + attrs, + ) + } + None => { + debug!("could not find container for method {} at {:?}", hir_id, span); + // This is not necessarily a bug, if there was a compilation error, + // the typeck results we need might not exist. + return None; + } + }, + }; + + let qualname = format!("{}::{}", qualname, ident.name); + + filter!(self.span_utils, ident.span); + + Some(Def { + kind: DefKind::Method, + id: id_from_def_id(def_id), + span: self.span_from_span(ident.span), + name: ident.name.to_string(), + qualname, + // FIXME you get better data here by using the visitor. + value: String::new(), + parent: parent_scope.map(id_from_def_id), + children: vec![], + decl_id: decl_id.map(id_from_def_id), + docs, + sig: None, + attributes: lower_attributes(attributes, self), + }) + } + + pub fn get_expr_data(&self, expr: &hir::Expr<'_>) -> Option<Data> { + let ty = self.typeck_results().expr_ty_adjusted_opt(expr)?; + if matches!(ty.kind(), ty::Error(_)) { + return None; + } + match expr.kind { + hir::ExprKind::Field(ref sub_ex, ident) => { + match self.typeck_results().expr_ty_adjusted(&sub_ex).kind() { + ty::Adt(def, _) if !def.is_enum() => { + let variant = &def.non_enum_variant(); + filter!(self.span_utils, ident.span); + let span = self.span_from_span(ident.span); + Some(Data::RefData(Ref { + kind: RefKind::Variable, + span, + ref_id: self + .tcx + .find_field_index(ident, variant) + .map(|index| id_from_def_id(variant.fields[index].did)) + .unwrap_or_else(null_id), + })) + } + ty::Tuple(..) => None, + _ => { + debug!("expected struct or union type, found {:?}", ty); + None + } + } + } + hir::ExprKind::Struct(qpath, ..) => match ty.kind() { + ty::Adt(def, _) => { + let sub_span = qpath.last_segment_span(); + filter!(self.span_utils, sub_span); + let span = self.span_from_span(sub_span); + Some(Data::RefData(Ref { + kind: RefKind::Type, + span, + ref_id: id_from_def_id(def.did()), + })) + } + _ => { + debug!("expected adt, found {:?}", ty); + None + } + }, + hir::ExprKind::MethodCall(ref seg, ..) => { + let Some(method_id) = self.typeck_results().type_dependent_def_id(expr.hir_id) else { + debug!("could not resolve method id for {:?}", expr); + return None; + }; + let (def_id, decl_id) = match self.tcx.associated_item(method_id).container { + ty::ImplContainer => (Some(method_id), None), + ty::TraitContainer => (None, Some(method_id)), + }; + let sub_span = seg.ident.span; + filter!(self.span_utils, sub_span); + let span = self.span_from_span(sub_span); + Some(Data::RefData(Ref { + kind: RefKind::Function, + span, + ref_id: def_id.or(decl_id).map(id_from_def_id).unwrap_or_else(null_id), + })) + } + hir::ExprKind::Path(ref path) => { + self.get_path_data(expr.hir_id, path).map(Data::RefData) + } + _ => { + // FIXME + bug!("invalid expression: {:?}", expr); + } + } + } + + pub fn get_path_res(&self, hir_id: hir::HirId) -> Res { + match self.tcx.hir().get(hir_id) { + Node::TraitRef(tr) => tr.path.res, + + Node::Item(&hir::Item { kind: hir::ItemKind::Use(path, _), .. }) => path.res, + Node::PathSegment(seg) => match seg.res { + Some(res) if res != Res::Err => res, + _ => { + let parent_node = self.tcx.hir().get_parent_node(hir_id); + self.get_path_res(parent_node) + } + }, + + Node::Expr(&hir::Expr { kind: hir::ExprKind::Struct(ref qpath, ..), .. }) => { + self.typeck_results().qpath_res(qpath, hir_id) + } + + Node::Expr(&hir::Expr { kind: hir::ExprKind::Path(ref qpath), .. }) + | Node::Pat(&hir::Pat { + kind: + hir::PatKind::Path(ref qpath) + | hir::PatKind::Struct(ref qpath, ..) + | hir::PatKind::TupleStruct(ref qpath, ..), + .. + }) + | Node::Ty(&hir::Ty { kind: hir::TyKind::Path(ref qpath), .. }) => match qpath { + hir::QPath::Resolved(_, path) => path.res, + hir::QPath::TypeRelative(..) | hir::QPath::LangItem(..) => { + // #75962: `self.typeck_results` may be different from the `hir_id`'s result. + if self.tcx.has_typeck_results(hir_id.owner.to_def_id()) { + self.tcx.typeck(hir_id.owner).qpath_res(qpath, hir_id) + } else { + Res::Err + } + } + }, + + Node::Pat(&hir::Pat { kind: hir::PatKind::Binding(_, canonical_id, ..), .. }) => { + Res::Local(canonical_id) + } + + _ => Res::Err, + } + } + + pub fn get_path_data(&self, id: hir::HirId, path: &hir::QPath<'_>) -> Option<Ref> { + let segment = match path { + hir::QPath::Resolved(_, path) => path.segments.last(), + hir::QPath::TypeRelative(_, segment) => Some(*segment), + hir::QPath::LangItem(..) => None, + }; + segment.and_then(|seg| { + self.get_path_segment_data(seg).or_else(|| self.get_path_segment_data_with_id(seg, id)) + }) + } + + pub fn get_path_segment_data(&self, path_seg: &hir::PathSegment<'_>) -> Option<Ref> { + self.get_path_segment_data_with_id(path_seg, path_seg.hir_id?) + } + + pub fn get_path_segment_data_with_id( + &self, + path_seg: &hir::PathSegment<'_>, + id: hir::HirId, + ) -> Option<Ref> { + // Returns true if the path is function type sugar, e.g., `Fn(A) -> B`. + fn fn_type(seg: &hir::PathSegment<'_>) -> bool { + seg.args.map_or(false, |args| args.parenthesized) + } + + let res = self.get_path_res(id); + let span = path_seg.ident.span; + filter!(self.span_utils, span); + let span = self.span_from_span(span); + + match res { + Res::Local(id) => { + Some(Ref { kind: RefKind::Variable, span, ref_id: id_from_hir_id(id, self) }) + } + Res::Def(HirDefKind::Trait, def_id) if fn_type(path_seg) => { + Some(Ref { kind: RefKind::Type, span, ref_id: id_from_def_id(def_id) }) + } + Res::Def( + HirDefKind::Struct + | HirDefKind::Variant + | HirDefKind::Union + | HirDefKind::Enum + | HirDefKind::TyAlias + | HirDefKind::ForeignTy + | HirDefKind::TraitAlias + | HirDefKind::AssocTy + | HirDefKind::Trait + | HirDefKind::OpaqueTy + | HirDefKind::TyParam, + def_id, + ) => Some(Ref { kind: RefKind::Type, span, ref_id: id_from_def_id(def_id) }), + Res::Def(HirDefKind::ConstParam, def_id) => { + Some(Ref { kind: RefKind::Variable, span, ref_id: id_from_def_id(def_id) }) + } + Res::Def(HirDefKind::Ctor(..), def_id) => { + // This is a reference to a tuple struct or an enum variant where the def_id points + // to an invisible constructor function. That is not a very useful + // def, so adjust to point to the tuple struct or enum variant itself. + let parent_def_id = self.tcx.parent(def_id); + Some(Ref { kind: RefKind::Type, span, ref_id: id_from_def_id(parent_def_id) }) + } + Res::Def(HirDefKind::Static(_) | HirDefKind::Const | HirDefKind::AssocConst, _) => { + Some(Ref { kind: RefKind::Variable, span, ref_id: id_from_def_id(res.def_id()) }) + } + Res::Def(HirDefKind::AssocFn, decl_id) => { + let def_id = if decl_id.is_local() { + if self.tcx.impl_defaultness(decl_id).has_value() { + Some(decl_id) + } else { + None + } + } else { + None + }; + Some(Ref { + kind: RefKind::Function, + span, + ref_id: id_from_def_id(def_id.unwrap_or(decl_id)), + }) + } + Res::Def(HirDefKind::Fn, def_id) => { + Some(Ref { kind: RefKind::Function, span, ref_id: id_from_def_id(def_id) }) + } + Res::Def(HirDefKind::Mod, def_id) => { + Some(Ref { kind: RefKind::Mod, span, ref_id: id_from_def_id(def_id) }) + } + + Res::Def( + HirDefKind::Macro(..) + | HirDefKind::ExternCrate + | HirDefKind::ForeignMod + | HirDefKind::LifetimeParam + | HirDefKind::AnonConst + | HirDefKind::InlineConst + | HirDefKind::Use + | HirDefKind::Field + | HirDefKind::GlobalAsm + | HirDefKind::Impl + | HirDefKind::Closure + | HirDefKind::Generator, + _, + ) + | Res::PrimTy(..) + | Res::SelfTy { .. } + | Res::ToolMod + | Res::NonMacroAttr(..) + | Res::SelfCtor(..) + | Res::Err => None, + } + } + + pub fn get_field_ref_data( + &self, + field_ref: &hir::ExprField<'_>, + variant: &ty::VariantDef, + ) -> Option<Ref> { + filter!(self.span_utils, field_ref.ident.span); + self.tcx.find_field_index(field_ref.ident, variant).map(|index| { + let span = self.span_from_span(field_ref.ident.span); + Ref { kind: RefKind::Variable, span, ref_id: id_from_def_id(variant.fields[index].did) } + }) + } + + /// Attempt to return MacroRef for any AST node. + /// + /// For a given piece of AST defined by the supplied Span and NodeId, + /// returns `None` if the node is not macro-generated or the span is malformed, + /// else uses the expansion callsite and callee to return some MacroRef. + /// + /// FIXME: [`DumpVisitor::process_macro_use`] should actually dump this data + #[allow(dead_code)] + fn get_macro_use_data(&self, span: Span) -> Option<MacroRef> { + if !generated_code(span) { + return None; + } + // Note we take care to use the source callsite/callee, to handle + // nested expansions and ensure we only generate data for source-visible + // macro uses. + let callsite = span.source_callsite(); + let callsite_span = self.span_from_span(callsite); + let callee = span.source_callee()?; + + let mac_name = match callee.kind { + ExpnKind::Macro(kind, name) => match kind { + MacroKind::Bang => name, + + // Ignore attribute macros, their spans are usually mangled + // FIXME(eddyb) is this really the case anymore? + MacroKind::Attr | MacroKind::Derive => return None, + }, + + // These are not macros. + // FIXME(eddyb) maybe there is a way to handle them usefully? + ExpnKind::Inlined | ExpnKind::Root | ExpnKind::AstPass(_) | ExpnKind::Desugaring(_) => { + return None; + } + }; + + let callee_span = self.span_from_span(callee.def_site); + Some(MacroRef { + span: callsite_span, + qualname: mac_name.to_string(), // FIXME: generate the real qualname + callee_span, + }) + } + + fn lookup_def_id(&self, ref_id: hir::HirId) -> Option<DefId> { + match self.get_path_res(ref_id) { + Res::PrimTy(_) | Res::SelfTy { .. } | Res::Err => None, + def => def.opt_def_id(), + } + } + + fn docs_for_attrs(&self, attrs: &[ast::Attribute]) -> String { + let mut result = String::new(); + + for attr in attrs { + if let Some((val, kind)) = attr.doc_str_and_comment_kind() { + // FIXME: Should save-analysis beautify doc strings itself or leave it to users? + result.push_str(beautify_doc_string(val, kind).as_str()); + result.push('\n'); + } + } + + if !self.config.full_docs { + if let Some(index) = result.find("\n\n") { + result.truncate(index); + } + } + + result + } + + fn next_impl_id(&self) -> u32 { + let next = self.impl_counter.get(); + self.impl_counter.set(next + 1); + next + } +} + +// An AST visitor for collecting paths (e.g., the names of structs) and formal +// variables (idents) from patterns. +struct PathCollector<'l> { + tcx: TyCtxt<'l>, + collected_paths: Vec<(hir::HirId, &'l hir::QPath<'l>)>, + collected_idents: Vec<(hir::HirId, Ident, hir::Mutability)>, +} + +impl<'l> PathCollector<'l> { + fn new(tcx: TyCtxt<'l>) -> PathCollector<'l> { + PathCollector { tcx, collected_paths: vec![], collected_idents: vec![] } + } +} + +impl<'l> Visitor<'l> for PathCollector<'l> { + type NestedFilter = nested_filter::All; + + fn nested_visit_map(&mut self) -> Self::Map { + self.tcx.hir() + } + + fn visit_pat(&mut self, p: &'l hir::Pat<'l>) { + match p.kind { + hir::PatKind::Struct(ref path, ..) => { + self.collected_paths.push((p.hir_id, path)); + } + hir::PatKind::TupleStruct(ref path, ..) | hir::PatKind::Path(ref path) => { + self.collected_paths.push((p.hir_id, path)); + } + hir::PatKind::Binding(bm, _, ident, _) => { + debug!( + "PathCollector, visit ident in pat {}: {:?} {:?}", + ident, p.span, ident.span + ); + let immut = match bm { + // Even if the ref is mut, you can't change the ref, only + // the data pointed at, so showing the initialising expression + // is still worthwhile. + hir::BindingAnnotation::Unannotated | hir::BindingAnnotation::Ref => { + hir::Mutability::Not + } + hir::BindingAnnotation::Mutable | hir::BindingAnnotation::RefMut => { + hir::Mutability::Mut + } + }; + self.collected_idents.push((p.hir_id, ident, immut)); + } + _ => {} + } + intravisit::walk_pat(self, p); + } +} + +/// Defines what to do with the results of saving the analysis. +pub trait SaveHandler { + fn save(&mut self, save_ctxt: &SaveContext<'_>, analysis: &Analysis); +} + +/// Dump the save-analysis results to a file. +pub struct DumpHandler<'a> { + odir: Option<&'a Path>, + cratename: String, +} + +impl<'a> DumpHandler<'a> { + pub fn new(odir: Option<&'a Path>, cratename: &str) -> DumpHandler<'a> { + DumpHandler { odir, cratename: cratename.to_owned() } + } + + fn output_file(&self, ctx: &SaveContext<'_>) -> (BufWriter<File>, PathBuf) { + let sess = &ctx.tcx.sess; + let file_name = match ctx.config.output_file { + Some(ref s) => PathBuf::from(s), + None => { + let mut root_path = match self.odir { + Some(val) => val.join("save-analysis"), + None => PathBuf::from("save-analysis-temp"), + }; + + if let Err(e) = std::fs::create_dir_all(&root_path) { + error!("Could not create directory {}: {}", root_path.display(), e); + } + + let executable = sess.crate_types().iter().any(|ct| *ct == CrateType::Executable); + let mut out_name = if executable { String::new() } else { "lib".to_owned() }; + out_name.push_str(&self.cratename); + out_name.push_str(&sess.opts.cg.extra_filename); + out_name.push_str(".json"); + root_path.push(&out_name); + + root_path + } + }; + + info!("Writing output to {}", file_name.display()); + + let output_file = BufWriter::new(File::create(&file_name).unwrap_or_else(|e| { + sess.fatal(&format!("Could not open {}: {}", file_name.display(), e)) + })); + + (output_file, file_name) + } +} + +impl SaveHandler for DumpHandler<'_> { + fn save(&mut self, save_ctxt: &SaveContext<'_>, analysis: &Analysis) { + let sess = &save_ctxt.tcx.sess; + let (output, file_name) = self.output_file(&save_ctxt); + if let Err(e) = serde_json::to_writer(output, &analysis) { + error!("Can't serialize save-analysis: {:?}", e); + } + + if sess.opts.json_artifact_notifications { + sess.parse_sess.span_diagnostic.emit_artifact_notification(&file_name, "save-analysis"); + } + } +} + +/// Call a callback with the results of save-analysis. +pub struct CallbackHandler<'b> { + pub callback: &'b mut dyn FnMut(&rls_data::Analysis), +} + +impl SaveHandler for CallbackHandler<'_> { + fn save(&mut self, _: &SaveContext<'_>, analysis: &Analysis) { + (self.callback)(analysis) + } +} + +pub fn process_crate<'l, 'tcx, H: SaveHandler>( + tcx: TyCtxt<'tcx>, + cratename: &str, + input: &'l Input, + config: Option<Config>, + mut handler: H, +) { + with_no_trimmed_paths!({ + tcx.dep_graph.with_ignore(|| { + info!("Dumping crate {}", cratename); + + // Privacy checking must be done outside of type inference; use a + // fallback in case the access levels couldn't have been correctly computed. + let access_levels = match tcx.sess.compile_status() { + Ok(..) => tcx.privacy_access_levels(()), + Err(..) => tcx.arena.alloc(AccessLevels::default()), + }; + + let save_ctxt = SaveContext { + tcx, + maybe_typeck_results: None, + access_levels: &access_levels, + span_utils: SpanUtils::new(&tcx.sess), + config: find_config(config), + impl_counter: Cell::new(0), + }; + + let mut visitor = DumpVisitor::new(save_ctxt); + + visitor.dump_crate_info(cratename); + visitor.dump_compilation_options(input, cratename); + visitor.process_crate(); + + handler.save(&visitor.save_ctxt, &visitor.analysis()) + }) + }) +} + +fn find_config(supplied: Option<Config>) -> Config { + if let Some(config) = supplied { + return config; + } + + match env::var_os("RUST_SAVE_ANALYSIS_CONFIG") { + None => Config::default(), + Some(config) => config + .to_str() + .ok_or(()) + .map_err(|_| error!("`RUST_SAVE_ANALYSIS_CONFIG` isn't UTF-8")) + .and_then(|cfg| { + serde_json::from_str(cfg) + .map_err(|_| error!("Could not deserialize save-analysis config")) + }) + .unwrap_or_default(), + } +} + +// Utility functions for the module. + +// Helper function to escape quotes in a string +fn escape(s: String) -> String { + s.replace('\"', "\"\"") +} + +// Helper function to determine if a span came from a +// macro expansion or syntax extension. +fn generated_code(span: Span) -> bool { + span.from_expansion() || span.is_dummy() +} + +// DefId::index is a newtype and so the JSON serialisation is ugly. Therefore +// we use our own Id which is the same, but without the newtype. +fn id_from_def_id(id: DefId) -> rls_data::Id { + rls_data::Id { krate: id.krate.as_u32(), index: id.index.as_u32() } +} + +fn id_from_hir_id(id: hir::HirId, scx: &SaveContext<'_>) -> rls_data::Id { + let def_id = scx.tcx.hir().opt_local_def_id(id); + def_id.map(|id| id_from_def_id(id.to_def_id())).unwrap_or_else(|| { + // Create a *fake* `DefId` out of a `HirId` by combining the owner + // `local_def_index` and the `local_id`. + // This will work unless you have *billions* of definitions in a single + // crate (very unlikely to actually happen). + rls_data::Id { + krate: LOCAL_CRATE.as_u32(), + index: id.owner.local_def_index.as_u32() | id.local_id.as_u32().reverse_bits(), + } + }) +} + +fn null_id() -> rls_data::Id { + rls_data::Id { krate: u32::MAX, index: u32::MAX } +} + +fn lower_attributes(attrs: Vec<ast::Attribute>, scx: &SaveContext<'_>) -> Vec<rls_data::Attribute> { + attrs + .into_iter() + // Only retain real attributes. Doc comments are lowered separately. + .filter(|attr| !attr.has_name(sym::doc)) + .map(|mut attr| { + // Remove the surrounding '#[..]' or '#![..]' of the pretty printed + // attribute. First normalize all inner attribute (#![..]) to outer + // ones (#[..]), then remove the two leading and the one trailing character. + attr.style = ast::AttrStyle::Outer; + let value = attribute_to_string(&attr); + // This str slicing works correctly, because the leading and trailing characters + // are in the ASCII range and thus exactly one byte each. + let value = value[2..value.len() - 1].to_string(); + + rls_data::Attribute { value, span: scx.span_from_span(attr.span) } + }) + .collect() +} diff --git a/compiler/rustc_save_analysis/src/sig.rs b/compiler/rustc_save_analysis/src/sig.rs new file mode 100644 index 000000000..d1286c9b8 --- /dev/null +++ b/compiler/rustc_save_analysis/src/sig.rs @@ -0,0 +1,917 @@ +// A signature is a string representation of an item's type signature, excluding +// any body. It also includes ids for any defs or refs in the signature. For +// example: +// +// ``` +// fn foo(x: String) { +// println!("{}", x); +// } +// ``` +// The signature string is something like "fn foo(x: String) {}" and the signature +// will have defs for `foo` and `x` and a ref for `String`. +// +// All signature text should parse in the correct context (i.e., in a module or +// impl, etc.). Clients may want to trim trailing `{}` or `;`. The text of a +// signature is not guaranteed to be stable (it may improve or change as the +// syntax changes, or whitespace or punctuation may change). It is also likely +// not to be pretty - no attempt is made to prettify the text. It is recommended +// that clients run the text through Rustfmt. +// +// This module generates Signatures for items by walking the AST and looking up +// references. +// +// Signatures do not include visibility info. I'm not sure if this is a feature +// or an omission (FIXME). +// +// FIXME where clauses need implementing, defs/refs in generics are mostly missing. + +use crate::{id_from_def_id, id_from_hir_id, SaveContext}; + +use rls_data::{SigElement, Signature}; + +use rustc_ast::Mutability; +use rustc_hir as hir; +use rustc_hir::def::{DefKind, Res}; +use rustc_hir_pretty::id_to_string; +use rustc_hir_pretty::{bounds_to_string, path_segment_to_string, path_to_string, ty_to_string}; +use rustc_span::symbol::{Ident, Symbol}; + +pub fn item_signature(item: &hir::Item<'_>, scx: &SaveContext<'_>) -> Option<Signature> { + if !scx.config.signatures { + return None; + } + item.make(0, None, scx).ok() +} + +pub fn foreign_item_signature( + item: &hir::ForeignItem<'_>, + scx: &SaveContext<'_>, +) -> Option<Signature> { + if !scx.config.signatures { + return None; + } + item.make(0, None, scx).ok() +} + +/// Signature for a struct or tuple field declaration. +/// Does not include a trailing comma. +pub fn field_signature(field: &hir::FieldDef<'_>, scx: &SaveContext<'_>) -> Option<Signature> { + if !scx.config.signatures { + return None; + } + field.make(0, None, scx).ok() +} + +/// Does not include a trailing comma. +pub fn variant_signature(variant: &hir::Variant<'_>, scx: &SaveContext<'_>) -> Option<Signature> { + if !scx.config.signatures { + return None; + } + variant.make(0, None, scx).ok() +} + +pub fn method_signature( + id: hir::HirId, + ident: Ident, + generics: &hir::Generics<'_>, + m: &hir::FnSig<'_>, + scx: &SaveContext<'_>, +) -> Option<Signature> { + if !scx.config.signatures { + return None; + } + make_method_signature(id, ident, generics, m, scx).ok() +} + +pub fn assoc_const_signature( + id: hir::HirId, + ident: Symbol, + ty: &hir::Ty<'_>, + default: Option<&hir::Expr<'_>>, + scx: &SaveContext<'_>, +) -> Option<Signature> { + if !scx.config.signatures { + return None; + } + make_assoc_const_signature(id, ident, ty, default, scx).ok() +} + +pub fn assoc_type_signature( + id: hir::HirId, + ident: Ident, + bounds: Option<hir::GenericBounds<'_>>, + default: Option<&hir::Ty<'_>>, + scx: &SaveContext<'_>, +) -> Option<Signature> { + if !scx.config.signatures { + return None; + } + make_assoc_type_signature(id, ident, bounds, default, scx).ok() +} + +type Result = std::result::Result<Signature, &'static str>; + +trait Sig { + fn make(&self, offset: usize, id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result; +} + +fn extend_sig( + mut sig: Signature, + text: String, + defs: Vec<SigElement>, + refs: Vec<SigElement>, +) -> Signature { + sig.text = text; + sig.defs.extend(defs.into_iter()); + sig.refs.extend(refs.into_iter()); + sig +} + +fn replace_text(mut sig: Signature, text: String) -> Signature { + sig.text = text; + sig +} + +fn merge_sigs(text: String, sigs: Vec<Signature>) -> Signature { + let mut result = Signature { text, defs: vec![], refs: vec![] }; + + let (defs, refs): (Vec<_>, Vec<_>) = sigs.into_iter().map(|s| (s.defs, s.refs)).unzip(); + + result.defs.extend(defs.into_iter().flat_map(|ds| ds.into_iter())); + result.refs.extend(refs.into_iter().flat_map(|rs| rs.into_iter())); + + result +} + +fn text_sig(text: String) -> Signature { + Signature { text, defs: vec![], refs: vec![] } +} + +impl<'hir> Sig for hir::Ty<'hir> { + fn make(&self, offset: usize, _parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result { + let id = Some(self.hir_id); + match self.kind { + hir::TyKind::Slice(ref ty) => { + let nested = ty.make(offset + 1, id, scx)?; + let text = format!("[{}]", nested.text); + Ok(replace_text(nested, text)) + } + hir::TyKind::Ptr(ref mt) => { + let prefix = match mt.mutbl { + hir::Mutability::Mut => "*mut ", + hir::Mutability::Not => "*const ", + }; + let nested = mt.ty.make(offset + prefix.len(), id, scx)?; + let text = format!("{}{}", prefix, nested.text); + Ok(replace_text(nested, text)) + } + hir::TyKind::Rptr(ref lifetime, ref mt) => { + let mut prefix = "&".to_owned(); + prefix.push_str(&lifetime.name.ident().to_string()); + prefix.push(' '); + if let hir::Mutability::Mut = mt.mutbl { + prefix.push_str("mut "); + }; + + let nested = mt.ty.make(offset + prefix.len(), id, scx)?; + let text = format!("{}{}", prefix, nested.text); + Ok(replace_text(nested, text)) + } + hir::TyKind::Never => Ok(text_sig("!".to_owned())), + hir::TyKind::Tup(ts) => { + let mut text = "(".to_owned(); + let mut defs = vec![]; + let mut refs = vec![]; + for t in ts { + let nested = t.make(offset + text.len(), id, scx)?; + text.push_str(&nested.text); + text.push(','); + defs.extend(nested.defs.into_iter()); + refs.extend(nested.refs.into_iter()); + } + text.push(')'); + Ok(Signature { text, defs, refs }) + } + hir::TyKind::BareFn(ref f) => { + let mut text = String::new(); + if !f.generic_params.is_empty() { + // FIXME defs, bounds on lifetimes + text.push_str("for<"); + text.push_str( + &f.generic_params + .iter() + .filter_map(|param| match param.kind { + hir::GenericParamKind::Lifetime { .. } => { + Some(param.name.ident().to_string()) + } + _ => None, + }) + .collect::<Vec<_>>() + .join(", "), + ); + text.push('>'); + } + + if let hir::Unsafety::Unsafe = f.unsafety { + text.push_str("unsafe "); + } + text.push_str("fn("); + + let mut defs = vec![]; + let mut refs = vec![]; + for i in f.decl.inputs { + let nested = i.make(offset + text.len(), Some(i.hir_id), scx)?; + text.push_str(&nested.text); + text.push(','); + defs.extend(nested.defs.into_iter()); + refs.extend(nested.refs.into_iter()); + } + text.push(')'); + if let hir::FnRetTy::Return(ref t) = f.decl.output { + text.push_str(" -> "); + let nested = t.make(offset + text.len(), None, scx)?; + text.push_str(&nested.text); + text.push(','); + defs.extend(nested.defs.into_iter()); + refs.extend(nested.refs.into_iter()); + } + + Ok(Signature { text, defs, refs }) + } + hir::TyKind::Path(hir::QPath::Resolved(None, ref path)) => path.make(offset, id, scx), + hir::TyKind::Path(hir::QPath::Resolved(Some(ref qself), ref path)) => { + let nested_ty = qself.make(offset + 1, id, scx)?; + let prefix = format!( + "<{} as {}>::", + nested_ty.text, + path_segment_to_string(&path.segments[0]) + ); + + let name = path_segment_to_string(path.segments.last().ok_or("Bad path")?); + let res = scx.get_path_res(id.ok_or("Missing id for Path")?); + let id = id_from_def_id(res.def_id()); + if path.segments.len() == 2 { + let start = offset + prefix.len(); + let end = start + name.len(); + + Ok(Signature { + text: prefix + &name, + defs: vec![], + refs: vec![SigElement { id, start, end }], + }) + } else { + let start = offset + prefix.len() + 5; + let end = start + name.len(); + // FIXME should put the proper path in there, not ellipsis. + Ok(Signature { + text: prefix + "...::" + &name, + defs: vec![], + refs: vec![SigElement { id, start, end }], + }) + } + } + hir::TyKind::Path(hir::QPath::TypeRelative(ty, segment)) => { + let nested_ty = ty.make(offset + 1, id, scx)?; + let prefix = format!("<{}>::", nested_ty.text); + + let name = path_segment_to_string(segment); + let res = scx.get_path_res(id.ok_or("Missing id for Path")?); + let id = id_from_def_id(res.def_id()); + + let start = offset + prefix.len(); + let end = start + name.len(); + Ok(Signature { + text: prefix + &name, + defs: vec![], + refs: vec![SigElement { id, start, end }], + }) + } + hir::TyKind::Path(hir::QPath::LangItem(lang_item, _, _)) => { + Ok(text_sig(format!("#[lang = \"{}\"]", lang_item.name()))) + } + hir::TyKind::TraitObject(bounds, ..) => { + // FIXME recurse into bounds + let bounds: Vec<hir::GenericBound<'_>> = bounds + .iter() + .map(|hir::PolyTraitRef { bound_generic_params, trait_ref, span }| { + hir::GenericBound::Trait( + hir::PolyTraitRef { + bound_generic_params, + trait_ref: hir::TraitRef { + path: trait_ref.path, + hir_ref_id: trait_ref.hir_ref_id, + }, + span: *span, + }, + hir::TraitBoundModifier::None, + ) + }) + .collect(); + let nested = bounds_to_string(&bounds); + Ok(text_sig(nested)) + } + hir::TyKind::Array(ref ty, ref length) => { + let nested_ty = ty.make(offset + 1, id, scx)?; + let expr = id_to_string(&scx.tcx.hir(), length.hir_id()).replace('\n', " "); + let text = format!("[{}; {}]", nested_ty.text, expr); + Ok(replace_text(nested_ty, text)) + } + hir::TyKind::OpaqueDef(item_id, _) => { + let item = scx.tcx.hir().item(item_id); + item.make(offset, Some(item_id.hir_id()), scx) + } + hir::TyKind::Typeof(_) | hir::TyKind::Infer | hir::TyKind::Err => Err("Ty"), + } + } +} + +impl<'hir> Sig for hir::Item<'hir> { + fn make(&self, offset: usize, _parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result { + let id = Some(self.hir_id()); + + match self.kind { + hir::ItemKind::Static(ref ty, m, ref body) => { + let mut text = "static ".to_owned(); + if m == hir::Mutability::Mut { + text.push_str("mut "); + } + let name = self.ident.to_string(); + let defs = vec![SigElement { + id: id_from_def_id(self.def_id.to_def_id()), + start: offset + text.len(), + end: offset + text.len() + name.len(), + }]; + text.push_str(&name); + text.push_str(": "); + + let ty = ty.make(offset + text.len(), id, scx)?; + text.push_str(&ty.text); + + text.push_str(" = "); + let expr = id_to_string(&scx.tcx.hir(), body.hir_id).replace('\n', " "); + text.push_str(&expr); + + text.push(';'); + + Ok(extend_sig(ty, text, defs, vec![])) + } + hir::ItemKind::Const(ref ty, ref body) => { + let mut text = "const ".to_owned(); + let name = self.ident.to_string(); + let defs = vec![SigElement { + id: id_from_def_id(self.def_id.to_def_id()), + start: offset + text.len(), + end: offset + text.len() + name.len(), + }]; + text.push_str(&name); + text.push_str(": "); + + let ty = ty.make(offset + text.len(), id, scx)?; + text.push_str(&ty.text); + + text.push_str(" = "); + let expr = id_to_string(&scx.tcx.hir(), body.hir_id).replace('\n', " "); + text.push_str(&expr); + + text.push(';'); + + Ok(extend_sig(ty, text, defs, vec![])) + } + hir::ItemKind::Fn(hir::FnSig { ref decl, header, span: _ }, ref generics, _) => { + let mut text = String::new(); + if let hir::Constness::Const = header.constness { + text.push_str("const "); + } + if hir::IsAsync::Async == header.asyncness { + text.push_str("async "); + } + if let hir::Unsafety::Unsafe = header.unsafety { + text.push_str("unsafe "); + } + text.push_str("fn "); + + let mut sig = + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; + + sig.text.push('('); + for i in decl.inputs { + // FIXME should descend into patterns to add defs. + sig.text.push_str(": "); + let nested = i.make(offset + sig.text.len(), Some(i.hir_id), scx)?; + sig.text.push_str(&nested.text); + sig.text.push(','); + sig.defs.extend(nested.defs.into_iter()); + sig.refs.extend(nested.refs.into_iter()); + } + sig.text.push(')'); + + if let hir::FnRetTy::Return(ref t) = decl.output { + sig.text.push_str(" -> "); + let nested = t.make(offset + sig.text.len(), None, scx)?; + sig.text.push_str(&nested.text); + sig.defs.extend(nested.defs.into_iter()); + sig.refs.extend(nested.refs.into_iter()); + } + sig.text.push_str(" {}"); + + Ok(sig) + } + hir::ItemKind::Macro(..) => { + let mut text = "macro".to_owned(); + let name = self.ident.to_string(); + text.push_str(&name); + text.push_str(&"! {}"); + + Ok(text_sig(text)) + } + hir::ItemKind::Mod(ref _mod) => { + let mut text = "mod ".to_owned(); + let name = self.ident.to_string(); + let defs = vec![SigElement { + id: id_from_def_id(self.def_id.to_def_id()), + start: offset + text.len(), + end: offset + text.len() + name.len(), + }]; + text.push_str(&name); + // Could be either `mod foo;` or `mod foo { ... }`, but we'll just pick one. + text.push(';'); + + Ok(Signature { text, defs, refs: vec![] }) + } + hir::ItemKind::TyAlias(ref ty, ref generics) => { + let text = "type ".to_owned(); + let mut sig = + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; + + sig.text.push_str(" = "); + let ty = ty.make(offset + sig.text.len(), id, scx)?; + sig.text.push_str(&ty.text); + sig.text.push(';'); + + Ok(merge_sigs(sig.text.clone(), vec![sig, ty])) + } + hir::ItemKind::Enum(_, ref generics) => { + let text = "enum ".to_owned(); + let mut sig = + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; + sig.text.push_str(" {}"); + Ok(sig) + } + hir::ItemKind::Struct(_, ref generics) => { + let text = "struct ".to_owned(); + let mut sig = + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; + sig.text.push_str(" {}"); + Ok(sig) + } + hir::ItemKind::Union(_, ref generics) => { + let text = "union ".to_owned(); + let mut sig = + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; + sig.text.push_str(" {}"); + Ok(sig) + } + hir::ItemKind::Trait(is_auto, unsafety, ref generics, bounds, _) => { + let mut text = String::new(); + + if is_auto == hir::IsAuto::Yes { + text.push_str("auto "); + } + + if let hir::Unsafety::Unsafe = unsafety { + text.push_str("unsafe "); + } + text.push_str("trait "); + let mut sig = + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; + + if !bounds.is_empty() { + sig.text.push_str(": "); + sig.text.push_str(&bounds_to_string(bounds)); + } + // FIXME where clause + sig.text.push_str(" {}"); + + Ok(sig) + } + hir::ItemKind::TraitAlias(ref generics, bounds) => { + let mut text = String::new(); + text.push_str("trait "); + let mut sig = + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; + + if !bounds.is_empty() { + sig.text.push_str(" = "); + sig.text.push_str(&bounds_to_string(bounds)); + } + // FIXME where clause + sig.text.push(';'); + + Ok(sig) + } + hir::ItemKind::Impl(hir::Impl { + unsafety, + polarity, + defaultness, + defaultness_span: _, + constness, + ref generics, + ref of_trait, + ref self_ty, + items: _, + }) => { + let mut text = String::new(); + if let hir::Defaultness::Default { .. } = defaultness { + text.push_str("default "); + } + if let hir::Unsafety::Unsafe = unsafety { + text.push_str("unsafe "); + } + text.push_str("impl"); + if let hir::Constness::Const = constness { + text.push_str(" const"); + } + + let generics_sig = generics.make(offset + text.len(), id, scx)?; + text.push_str(&generics_sig.text); + + text.push(' '); + + let trait_sig = if let Some(ref t) = *of_trait { + if let hir::ImplPolarity::Negative(_) = polarity { + text.push('!'); + } + let trait_sig = t.path.make(offset + text.len(), id, scx)?; + text.push_str(&trait_sig.text); + text.push_str(" for "); + trait_sig + } else { + text_sig(String::new()) + }; + + let ty_sig = self_ty.make(offset + text.len(), id, scx)?; + text.push_str(&ty_sig.text); + + text.push_str(" {}"); + + Ok(merge_sigs(text, vec![generics_sig, trait_sig, ty_sig])) + + // FIXME where clause + } + hir::ItemKind::ForeignMod { .. } => Err("extern mod"), + hir::ItemKind::GlobalAsm(_) => Err("global asm"), + hir::ItemKind::ExternCrate(_) => Err("extern crate"), + hir::ItemKind::OpaqueTy(..) => Err("opaque type"), + // FIXME should implement this (e.g., pub use). + hir::ItemKind::Use(..) => Err("import"), + } + } +} + +impl<'hir> Sig for hir::Path<'hir> { + fn make(&self, offset: usize, id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result { + let res = scx.get_path_res(id.ok_or("Missing id for Path")?); + + let (name, start, end) = match res { + Res::PrimTy(..) | Res::SelfTy { .. } | Res::Err => { + return Ok(Signature { text: path_to_string(self), defs: vec![], refs: vec![] }); + } + Res::Def(DefKind::AssocConst | DefKind::Variant | DefKind::Ctor(..), _) => { + let len = self.segments.len(); + if len < 2 { + return Err("Bad path"); + } + // FIXME: really we should descend into the generics here and add SigElements for + // them. + // FIXME: would be nice to have a def for the first path segment. + let seg1 = path_segment_to_string(&self.segments[len - 2]); + let seg2 = path_segment_to_string(&self.segments[len - 1]); + let start = offset + seg1.len() + 2; + (format!("{}::{}", seg1, seg2), start, start + seg2.len()) + } + _ => { + let name = path_segment_to_string(self.segments.last().ok_or("Bad path")?); + let end = offset + name.len(); + (name, offset, end) + } + }; + + let id = id_from_def_id(res.def_id()); + Ok(Signature { text: name, defs: vec![], refs: vec![SigElement { id, start, end }] }) + } +} + +// This does not cover the where clause, which must be processed separately. +impl<'hir> Sig for hir::Generics<'hir> { + fn make(&self, offset: usize, _parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result { + if self.params.is_empty() { + return Ok(text_sig(String::new())); + } + + let mut text = "<".to_owned(); + + let mut defs = Vec::with_capacity(self.params.len()); + for param in self.params { + let mut param_text = String::new(); + if let hir::GenericParamKind::Const { .. } = param.kind { + param_text.push_str("const "); + } + param_text.push_str(param.name.ident().as_str()); + defs.push(SigElement { + id: id_from_hir_id(param.hir_id, scx), + start: offset + text.len(), + end: offset + text.len() + param_text.as_str().len(), + }); + if let hir::GenericParamKind::Const { ref ty, default } = param.kind { + param_text.push_str(": "); + param_text.push_str(&ty_to_string(&ty)); + if let Some(default) = default { + param_text.push_str(" = "); + param_text.push_str(&id_to_string(&scx.tcx.hir(), default.hir_id)); + } + } + text.push_str(¶m_text); + text.push(','); + } + + text.push('>'); + Ok(Signature { text, defs, refs: vec![] }) + } +} + +impl<'hir> Sig for hir::FieldDef<'hir> { + fn make(&self, offset: usize, _parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result { + let mut text = String::new(); + + text.push_str(&self.ident.to_string()); + let defs = Some(SigElement { + id: id_from_hir_id(self.hir_id, scx), + start: offset, + end: offset + text.len(), + }); + text.push_str(": "); + + let mut ty_sig = self.ty.make(offset + text.len(), Some(self.hir_id), scx)?; + text.push_str(&ty_sig.text); + ty_sig.text = text; + ty_sig.defs.extend(defs.into_iter()); + Ok(ty_sig) + } +} + +impl<'hir> Sig for hir::Variant<'hir> { + fn make(&self, offset: usize, parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result { + let mut text = self.ident.to_string(); + match self.data { + hir::VariantData::Struct(fields, r) => { + let id = parent_id.ok_or("Missing id for Variant's parent")?; + let name_def = SigElement { + id: id_from_hir_id(id, scx), + start: offset, + end: offset + text.len(), + }; + text.push_str(" { "); + let mut defs = vec![name_def]; + let mut refs = vec![]; + if r { + text.push_str("/* parse error */ "); + } else { + for f in fields { + let field_sig = f.make(offset + text.len(), Some(id), scx)?; + text.push_str(&field_sig.text); + text.push_str(", "); + defs.extend(field_sig.defs.into_iter()); + refs.extend(field_sig.refs.into_iter()); + } + } + text.push('}'); + Ok(Signature { text, defs, refs }) + } + hir::VariantData::Tuple(fields, id) => { + let name_def = SigElement { + id: id_from_hir_id(id, scx), + start: offset, + end: offset + text.len(), + }; + text.push('('); + let mut defs = vec![name_def]; + let mut refs = vec![]; + for f in fields { + let field_sig = f.make(offset + text.len(), Some(id), scx)?; + text.push_str(&field_sig.text); + text.push_str(", "); + defs.extend(field_sig.defs.into_iter()); + refs.extend(field_sig.refs.into_iter()); + } + text.push(')'); + Ok(Signature { text, defs, refs }) + } + hir::VariantData::Unit(id) => { + let name_def = SigElement { + id: id_from_hir_id(id, scx), + start: offset, + end: offset + text.len(), + }; + Ok(Signature { text, defs: vec![name_def], refs: vec![] }) + } + } + } +} + +impl<'hir> Sig for hir::ForeignItem<'hir> { + fn make(&self, offset: usize, _parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result { + let id = Some(self.hir_id()); + match self.kind { + hir::ForeignItemKind::Fn(decl, _, ref generics) => { + let mut text = String::new(); + text.push_str("fn "); + + let mut sig = + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; + + sig.text.push('('); + for i in decl.inputs { + sig.text.push_str(": "); + let nested = i.make(offset + sig.text.len(), Some(i.hir_id), scx)?; + sig.text.push_str(&nested.text); + sig.text.push(','); + sig.defs.extend(nested.defs.into_iter()); + sig.refs.extend(nested.refs.into_iter()); + } + sig.text.push(')'); + + if let hir::FnRetTy::Return(ref t) = decl.output { + sig.text.push_str(" -> "); + let nested = t.make(offset + sig.text.len(), None, scx)?; + sig.text.push_str(&nested.text); + sig.defs.extend(nested.defs.into_iter()); + sig.refs.extend(nested.refs.into_iter()); + } + sig.text.push(';'); + + Ok(sig) + } + hir::ForeignItemKind::Static(ref ty, m) => { + let mut text = "static ".to_owned(); + if m == Mutability::Mut { + text.push_str("mut "); + } + let name = self.ident.to_string(); + let defs = vec![SigElement { + id: id_from_def_id(self.def_id.to_def_id()), + start: offset + text.len(), + end: offset + text.len() + name.len(), + }]; + text.push_str(&name); + text.push_str(": "); + + let ty_sig = ty.make(offset + text.len(), id, scx)?; + text.push(';'); + + Ok(extend_sig(ty_sig, text, defs, vec![])) + } + hir::ForeignItemKind::Type => { + let mut text = "type ".to_owned(); + let name = self.ident.to_string(); + let defs = vec![SigElement { + id: id_from_def_id(self.def_id.to_def_id()), + start: offset + text.len(), + end: offset + text.len() + name.len(), + }]; + text.push_str(&name); + text.push(';'); + + Ok(Signature { text, defs, refs: vec![] }) + } + } + } +} + +fn name_and_generics( + mut text: String, + offset: usize, + generics: &hir::Generics<'_>, + id: hir::HirId, + name: Ident, + scx: &SaveContext<'_>, +) -> Result { + let name = name.to_string(); + let def = SigElement { + id: id_from_hir_id(id, scx), + start: offset + text.len(), + end: offset + text.len() + name.len(), + }; + text.push_str(&name); + let generics: Signature = generics.make(offset + text.len(), Some(id), scx)?; + // FIXME where clause + let text = format!("{}{}", text, generics.text); + Ok(extend_sig(generics, text, vec![def], vec![])) +} + +fn make_assoc_type_signature( + id: hir::HirId, + ident: Ident, + bounds: Option<hir::GenericBounds<'_>>, + default: Option<&hir::Ty<'_>>, + scx: &SaveContext<'_>, +) -> Result { + let mut text = "type ".to_owned(); + let name = ident.to_string(); + let mut defs = vec![SigElement { + id: id_from_hir_id(id, scx), + start: text.len(), + end: text.len() + name.len(), + }]; + let mut refs = vec![]; + text.push_str(&name); + if let Some(bounds) = bounds { + text.push_str(": "); + // FIXME should descend into bounds + text.push_str(&bounds_to_string(bounds)); + } + if let Some(default) = default { + text.push_str(" = "); + let ty_sig = default.make(text.len(), Some(id), scx)?; + text.push_str(&ty_sig.text); + defs.extend(ty_sig.defs.into_iter()); + refs.extend(ty_sig.refs.into_iter()); + } + text.push(';'); + Ok(Signature { text, defs, refs }) +} + +fn make_assoc_const_signature( + id: hir::HirId, + ident: Symbol, + ty: &hir::Ty<'_>, + default: Option<&hir::Expr<'_>>, + scx: &SaveContext<'_>, +) -> Result { + let mut text = "const ".to_owned(); + let name = ident.to_string(); + let mut defs = vec![SigElement { + id: id_from_hir_id(id, scx), + start: text.len(), + end: text.len() + name.len(), + }]; + let mut refs = vec![]; + text.push_str(&name); + text.push_str(": "); + + let ty_sig = ty.make(text.len(), Some(id), scx)?; + text.push_str(&ty_sig.text); + defs.extend(ty_sig.defs.into_iter()); + refs.extend(ty_sig.refs.into_iter()); + + if let Some(default) = default { + text.push_str(" = "); + text.push_str(&id_to_string(&scx.tcx.hir(), default.hir_id)); + } + text.push(';'); + Ok(Signature { text, defs, refs }) +} + +fn make_method_signature( + id: hir::HirId, + ident: Ident, + generics: &hir::Generics<'_>, + m: &hir::FnSig<'_>, + scx: &SaveContext<'_>, +) -> Result { + // FIXME code dup with function signature + let mut text = String::new(); + if let hir::Constness::Const = m.header.constness { + text.push_str("const "); + } + if hir::IsAsync::Async == m.header.asyncness { + text.push_str("async "); + } + if let hir::Unsafety::Unsafe = m.header.unsafety { + text.push_str("unsafe "); + } + text.push_str("fn "); + + let mut sig = name_and_generics(text, 0, generics, id, ident, scx)?; + + sig.text.push('('); + for i in m.decl.inputs { + sig.text.push_str(": "); + let nested = i.make(sig.text.len(), Some(i.hir_id), scx)?; + sig.text.push_str(&nested.text); + sig.text.push(','); + sig.defs.extend(nested.defs.into_iter()); + sig.refs.extend(nested.refs.into_iter()); + } + sig.text.push(')'); + + if let hir::FnRetTy::Return(ref t) = m.decl.output { + sig.text.push_str(" -> "); + let nested = t.make(sig.text.len(), None, scx)?; + sig.text.push_str(&nested.text); + sig.defs.extend(nested.defs.into_iter()); + sig.refs.extend(nested.refs.into_iter()); + } + sig.text.push_str(" {}"); + + Ok(sig) +} diff --git a/compiler/rustc_save_analysis/src/span_utils.rs b/compiler/rustc_save_analysis/src/span_utils.rs new file mode 100644 index 000000000..8d6758f40 --- /dev/null +++ b/compiler/rustc_save_analysis/src/span_utils.rs @@ -0,0 +1,102 @@ +use crate::generated_code; +use rustc_data_structures::sync::Lrc; +use rustc_lexer::{tokenize, TokenKind}; +use rustc_session::Session; +use rustc_span::*; + +#[derive(Clone)] +pub struct SpanUtils<'a> { + pub sess: &'a Session, +} + +impl<'a> SpanUtils<'a> { + pub fn new(sess: &'a Session) -> SpanUtils<'a> { + SpanUtils { sess } + } + + pub fn make_filename_string(&self, file: &SourceFile) -> String { + match &file.name { + FileName::Real(RealFileName::LocalPath(path)) => { + if path.is_absolute() { + self.sess + .source_map() + .path_mapping() + .map_prefix(path.into()) + .0 + .display() + .to_string() + } else { + self.sess + .opts + .working_dir + .remapped_path_if_available() + .join(&path) + .display() + .to_string() + } + } + filename => filename.prefer_remapped().to_string(), + } + } + + pub fn snippet(&self, span: Span) -> String { + match self.sess.source_map().span_to_snippet(span) { + Ok(s) => s, + Err(_) => String::new(), + } + } + + /// Finds the span of `*` token withing the larger `span`. + pub fn sub_span_of_star(&self, mut span: Span) -> Option<Span> { + let begin = self.sess.source_map().lookup_byte_offset(span.lo()); + let end = self.sess.source_map().lookup_byte_offset(span.hi()); + // Make the range zero-length if the span is invalid. + if begin.sf.start_pos != end.sf.start_pos { + span = span.shrink_to_lo(); + } + + let sf = Lrc::clone(&begin.sf); + + self.sess.source_map().ensure_source_file_source_present(Lrc::clone(&sf)); + let src = + sf.src.clone().or_else(|| sf.external_src.borrow().get_source().map(Lrc::clone))?; + let to_index = |pos: BytePos| -> usize { (pos - sf.start_pos).0 as usize }; + let text = &src[to_index(span.lo())..to_index(span.hi())]; + let start_pos = { + let mut pos = 0; + tokenize(text) + .map(|token| { + let start = pos; + pos += token.len; + (start, token) + }) + .find(|(_pos, token)| token.kind == TokenKind::Star)? + .0 + }; + let lo = span.lo() + BytePos(start_pos as u32); + let hi = lo + BytePos(1); + Some(span.with_lo(lo).with_hi(hi)) + } + + /// Return true if the span is generated code, and + /// it is not a subspan of the root callsite. + /// + /// Used to filter out spans of minimal value, + /// such as references to macro internal variables. + pub fn filter_generated(&self, span: Span) -> bool { + if generated_code(span) { + return true; + } + + //If the span comes from a fake source_file, filter it. + !self.sess.source_map().lookup_char_pos(span.lo()).file.is_real_file() + } +} + +macro_rules! filter { + ($util: expr, $parent: expr) => { + if $util.filter_generated($parent) { + return None; + } + }; +} |