Skip to content

Extended save-analysis to support generated code #31097

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jan 25, 2016
Merged

Extended save-analysis to support generated code #31097

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
213 changes: 86 additions & 127 deletions src/librustc_trans/save/dump_csv.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -135,6 +135,9 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
// always using the first ones. So, only error out if we don't have enough spans.
// What could go wrong...?
if spans.len() < path.segments.len() {
if generated_code(path.span) {
return vec!();
}
error!("Mis-calculated spans for path '{}'. Found {} spans, expected {}. Found spans:",
path_to_string(path),
spans.len(),
Expand Down Expand Up @@ -308,28 +311,26 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
id: ast::NodeId,
name: ast::Name,
span: Span) {
if generated_code(span) {
return;
}

debug!("process_method: {}:{}", id, name);

let method_data = self.save_ctxt.get_method_data(id, name, span);
if let Some(method_data) = self.save_ctxt.get_method_data(id, name, span) {

if body.is_some() {
self.fmt.method_str(span,
Some(method_data.span),
method_data.id,
&method_data.qualname,
method_data.declaration,
method_data.scope);
self.process_formals(&sig.decl.inputs, &method_data.qualname);
} else {
self.fmt.method_decl_str(span,
Some(method_data.span),
method_data.id,
&method_data.qualname,
method_data.scope);
if body.is_some() {
self.fmt.method_str(span,
Some(method_data.span),
method_data.id,
&method_data.qualname,
method_data.declaration,
method_data.scope);
self.process_formals(&sig.decl.inputs, &method_data.qualname);
} else {
self.fmt.method_decl_str(span,
Some(method_data.span),
method_data.id,
&method_data.qualname,
method_data.scope);
}
self.process_generic_params(&sig.generics, span, &method_data.qualname, id);
}

// walk arg and return types
Expand All @@ -345,8 +346,6 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
if let Some(body) = body {
self.nest(id, |v| v.visit_block(body));
}

self.process_generic_params(&sig.generics, span, &method_data.qualname, id);
}

fn process_trait_ref(&mut self, trait_ref: &ast::TraitRef) {
Expand Down Expand Up @@ -402,17 +401,17 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
decl: &ast::FnDecl,
ty_params: &ast::Generics,
body: &ast::Block) {
let fn_data = self.save_ctxt.get_item_data(item);
down_cast_data!(fn_data, FunctionData, self, item.span);
self.fmt.fn_str(item.span,
Some(fn_data.span),
fn_data.id,
&fn_data.qualname,
fn_data.scope);


self.process_formals(&decl.inputs, &fn_data.qualname);
self.process_generic_params(ty_params, item.span, &fn_data.qualname, item.id);
if let Some(fn_data) = self.save_ctxt.get_item_data(item) {
down_cast_data!(fn_data, FunctionData, self, item.span);
self.fmt.fn_str(item.span,
Some(fn_data.span),
fn_data.id,
&fn_data.qualname,
fn_data.scope);

self.process_formals(&decl.inputs, &fn_data.qualname);
self.process_generic_params(ty_params, item.span, &fn_data.qualname, item.id);
}

for arg in &decl.inputs {
self.visit_ty(&arg.ty);
Expand All @@ -426,17 +425,17 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
}

fn process_static_or_const_item(&mut self, item: &ast::Item, typ: &ast::Ty, expr: &ast::Expr) {
let var_data = self.save_ctxt.get_item_data(item);
down_cast_data!(var_data, VariableData, self, item.span);
self.fmt.static_str(item.span,
Some(var_data.span),
var_data.id,
&var_data.name,
&var_data.qualname,
&var_data.value,
&var_data.type_value,
var_data.scope);

if let Some(var_data) = self.save_ctxt.get_item_data(item) {
down_cast_data!(var_data, VariableData, self, item.span);
self.fmt.static_str(item.span,
Some(var_data.span),
var_data.id,
&var_data.name,
&var_data.qualname,
&var_data.value,
&var_data.type_value,
var_data.scope);
}
self.visit_ty(&typ);
self.visit_expr(expr);
}
Expand Down Expand Up @@ -495,6 +494,10 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
enum_definition: &ast::EnumDef,
ty_params: &ast::Generics) {
let enum_data = self.save_ctxt.get_item_data(item);
let enum_data = match enum_data {
None => return,
Some(data) => data,
};
down_cast_data!(enum_data, EnumData, self, item.span);
self.fmt.enum_str(item.span,
Some(enum_data.span),
Expand Down Expand Up @@ -533,36 +536,36 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
trait_ref: &Option<ast::TraitRef>,
typ: &ast::Ty,
impl_items: &[P<ast::ImplItem>]) {
let impl_data = self.save_ctxt.get_item_data(item);
down_cast_data!(impl_data, ImplData, self, item.span);
match impl_data.self_ref {
Some(ref self_ref) => {
let mut has_self_ref = false;
if let Some(impl_data) = self.save_ctxt.get_item_data(item) {
down_cast_data!(impl_data, ImplData, self, item.span);
if let Some(ref self_ref) = impl_data.self_ref {
has_self_ref = true;
self.fmt.ref_str(recorder::TypeRef,
item.span,
Some(self_ref.span),
self_ref.ref_id,
self_ref.scope);
}
None => {
self.visit_ty(&typ);
if let Some(ref trait_ref_data) = impl_data.trait_ref {
self.fmt.ref_str(recorder::TypeRef,
item.span,
Some(trait_ref_data.span),
trait_ref_data.ref_id,
trait_ref_data.scope);
visit::walk_path(self, &trait_ref.as_ref().unwrap().path);
}

self.fmt.impl_str(item.span,
Some(impl_data.span),
impl_data.id,
impl_data.self_ref.map(|data| data.ref_id),
impl_data.trait_ref.map(|data| data.ref_id),
impl_data.scope);
}
if let Some(ref trait_ref_data) = impl_data.trait_ref {
self.fmt.ref_str(recorder::TypeRef,
item.span,
Some(trait_ref_data.span),
trait_ref_data.ref_id,
trait_ref_data.scope);
visit::walk_path(self, &trait_ref.as_ref().unwrap().path);
if !has_self_ref {
self.visit_ty(&typ);
}

self.fmt.impl_str(item.span,
Some(impl_data.span),
impl_data.id,
impl_data.self_ref.map(|data| data.ref_id),
impl_data.trait_ref.map(|data| data.ref_id),
impl_data.scope);

self.process_generic_params(type_parameters, item.span, "", item.id);
for impl_item in impl_items {
self.visit_impl_item(impl_item);
Expand Down Expand Up @@ -619,22 +622,23 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {

// `item` is the module in question, represented as an item.
fn process_mod(&mut self, item: &ast::Item) {
let mod_data = self.save_ctxt.get_item_data(item);
down_cast_data!(mod_data, ModData, self, item.span);
self.fmt.mod_str(item.span,
Some(mod_data.span),
mod_data.id,
&mod_data.qualname,
mod_data.scope,
&mod_data.filename);
if let Some(mod_data) = self.save_ctxt.get_item_data(item) {
down_cast_data!(mod_data, ModData, self, item.span);
self.fmt.mod_str(item.span,
Some(mod_data.span),
mod_data.id,
&mod_data.qualname,
mod_data.scope,
&mod_data.filename);
}
}

fn process_path(&mut self, id: NodeId, path: &ast::Path, ref_kind: Option<recorder::Row>) {
if generated_code(path.span) {
let path_data = self.save_ctxt.get_path_data(id, path);
if generated_code(path.span) && path_data.is_none() {
return;
}

let path_data = self.save_ctxt.get_path_data(id, path);
let path_data = match path_data {
Some(pd) => pd,
None => {
Expand Down Expand Up @@ -705,10 +709,6 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
fields: &Vec<ast::Field>,
variant: ty::VariantDef,
base: &Option<P<ast::Expr>>) {
if generated_code(path.span) {
return
}

self.write_sub_paths_truncated(path, false);

if let Some(struct_lit_data) = self.save_ctxt.get_expr_data(ex) {
Expand All @@ -721,16 +721,15 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
let scope = self.save_ctxt.enclosing_scope(ex.id);

for field in fields {
if generated_code(field.ident.span) {
continue;
}
if let Some(field_data) = self.save_ctxt
.get_field_ref_data(field, variant, scope) {

let field_data = self.save_ctxt.get_field_ref_data(field, variant, scope);
self.fmt.ref_str(recorder::VarRef,
field.ident.span,
Some(field_data.span),
field_data.ref_id,
field_data.scope);
self.fmt.ref_str(recorder::VarRef,
field.ident.span,
Some(field_data.span),
field_data.ref_id,
field_data.scope);
}

self.visit_expr(&field.expr)
}
Expand All @@ -754,10 +753,6 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
}

fn process_pat(&mut self, p: &ast::Pat) {
if generated_code(p.span) {
return;
}

match p.node {
ast::PatStruct(ref path, ref fields, _) => {
visit::walk_path(self, path);
Expand All @@ -766,10 +761,6 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
let variant = adt.variant_of_def(def);

for &Spanned { node: ref field, span } in fields {
if generated_code(span) {
continue;
}

let sub_span = self.span.span_for_first_ident(span);
if let Some(f) = variant.find_field_named(field.ident.name) {
self.fmt.ref_str(recorder::VarRef, span, sub_span, f.did, self.cur_scope);
Expand Down Expand Up @@ -813,10 +804,6 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {

impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
fn visit_item(&mut self, item: &ast::Item) {
if generated_code(item.span) {
return
}

match item.node {
ast::ItemUse(ref use_item) => {
match use_item.node {
Expand Down Expand Up @@ -1011,10 +998,6 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
}

fn visit_ty(&mut self, t: &ast::Ty) {
if generated_code(t.span) {
return
}

match t.node {
ast::TyPath(_, ref path) => {
match self.lookup_type_ref(t.id) {
Expand All @@ -1034,10 +1017,6 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
}

fn visit_expr(&mut self, ex: &ast::Expr) {
if generated_code(ex.span) {
return
}

match ex.node {
ast::ExprCall(ref _f, ref _args) => {
// Don't need to do anything for function calls,
Expand All @@ -1056,10 +1035,6 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
}
ast::ExprMethodCall(_, _, ref args) => self.process_method_call(ex, args),
ast::ExprField(ref sub_ex, _) => {
if generated_code(sub_ex.span) {
return
}

self.visit_expr(&sub_ex);

if let Some(field_data) = self.save_ctxt.get_expr_data(ex) {
Expand All @@ -1072,10 +1047,6 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
}
}
ast::ExprTupField(ref sub_ex, idx) => {
if generated_code(sub_ex.span) {
return
}

self.visit_expr(&**sub_ex);

let hir_node = lower_expr(self.save_ctxt.lcx, sub_ex);
Expand All @@ -1096,10 +1067,6 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
}
}
ast::ExprClosure(_, ref decl, ref body) => {
if generated_code(body.span) {
return
}

let mut id = String::from("$");
id.push_str(&ex.id.to_string());
self.process_formals(&decl.inputs, &id);
Expand Down Expand Up @@ -1196,18 +1163,10 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
}

fn visit_stmt(&mut self, s: &ast::Stmt) {
if generated_code(s.span) {
return
}

visit::walk_stmt(self, s)
}

fn visit_local(&mut self, l: &ast::Local) {
if generated_code(l.span) {
return
}

let value = self.span.snippet(l.span);
self.process_var_decl(&l.pat, value);

Expand Down
Loading