Merge #992

992: Cleanup bad unused code warnings r=philberty a=philberty

This patchset contains 4 distinct fixes:

When a constant is declared after where it is used the code-generation pass falls
back to a query compilation of the HIR::Item this did not contain a check to verify
if it was already compiled and results in duplicate CONST_DECLS being generated
if query compilation was used.

We were using a zero precision integer to contain unit-type expressions this results
in VAR_DECLS being lost in the GENERIC graph which does not allow us to perform
any static analysis upon the DECL. This changes the unit type to use an empty struct
and for initialization of a VAR_DECL we can simply pass an empty constructor and let 
GCC optimize this code for us.

Update our DEAD_CODE scan to take into account modules of items and also respect
if structures are prefixed with an underscore we can ignore generating an unused warning.

Remove our AST scan for unused code and reuse GCC TREE_USED to track wether
VAR_DECL, PARM_DECL, CONST_DECL are actually used or not. We reuse the GCC
walk_tree functions to have this as nice separate lint.

Fixes #676 

Co-authored-by: Philip Herron <philip.herron@embecosm.com>

1 files changed, 18 insertions, 4 deletions

diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc
index e41ee7f..09f3860 100644
--- a/gcc/rust/backend/rust-compile-resolve-path.cc
+++ b/gcc/rust/backend/rust-compile-resolve-path.cc
@@ -23,6 +23,8 @@
 #include "rust-hir-trait-resolve.h"
 #include "rust-hir-path-probe.h"
 
+#include "print-tree.h"
+
 namespace Rust {
 namespace Compile {
 
@@ -117,12 +119,18 @@ ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment,
   // might be a constant
   tree constant_expr;
   if (ctx->lookup_const_decl (ref, &constant_expr))
-    return constant_expr;
+    {
+      TREE_USED (constant_expr) = 1;
+      return constant_expr;
+    }
 
   // this might be a variable reference or a function reference
   Bvariable *var = nullptr;
   if (ctx->lookup_var_decl (ref, &var))
-    return ctx->get_backend ()->var_expression (var, expr_locus);
+    {
+      // TREE_USED is setup in the gcc abstraction here
+      return ctx->get_backend ()->var_expression (var, expr_locus);
+    }
 
   // it might be a function call
   if (lookup->get_kind () == TyTy::TypeKind::FNDEF)
@@ -131,13 +139,19 @@ ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment,
       tree fn = NULL_TREE;
       if (ctx->lookup_function_decl (fntype->get_ty_ref (), &fn))
 	{
+	  TREE_USED (fn) = 1;
 	  return address_expression (fn, expr_locus);
 	}
     }
 
   // let the query system figure it out
-  return query_compile (ref, lookup, final_segment, mappings, expr_locus,
-			is_qualified_path);
+  tree resolved_item = query_compile (ref, lookup, final_segment, mappings,
+				      expr_locus, is_qualified_path);
+  if (resolved_item != error_mark_node)
+    {
+      TREE_USED (resolved_item) = 1;
+    }
+  return resolved_item;
 }
 
 tree