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>

Author: bors[bot]

gcc/rust/Make-lang.in

@@ -101,6 +101,7 @@ GRS_OBJS = \
     rust/rust-autoderef.o \
     rust/rust-substitution-mapper.o \
     rust/rust-lint-marklive.o \
+    rust/rust-lint-unused-var.o \
     rust/rust-hir-type-check-path.o \
     rust/rust-compile-intrinsic.o \
     rust/rust-compile-pattern.o \

gcc/rust/backend/rust-compile-context.h

@@ -307,6 +307,11 @@ class Context
     return mangler.mangle_item (ty, path);
   }
 
+  std::vector<tree> &get_type_decls () { return type_decls; }
+  std::vector<::Bvariable *> &get_var_decls () { return var_decls; }
+  std::vector<tree> &get_const_decls () { return const_decls; }
+  std::vector<tree> &get_func_decls () { return func_decls; }
+
 private:
   ::Backend *backend;
   Resolver::Resolver *resolver;

gcc/rust/backend/rust-compile-expr.cc

@@ -1339,18 +1339,22 @@ CompileExpr::visit (HIR::IdentifierExpr &expr)
   Bvariable *var = nullptr;
   if (ctx->lookup_const_decl (ref, &translated))
     {
+      TREE_USED (translated) = 1;
       return;
     }
   else if (ctx->lookup_function_decl (ref, &fn))
     {
+      TREE_USED (fn) = 1;
       translated = address_expression (fn, expr.get_locus ());
     }
   else if (ctx->lookup_var_decl (ref, &var))
     {
+      // TREE_USED is setup in the gcc abstraction here
       translated = ctx->get_backend ()->var_expression (var, expr.get_locus ());
     }
   else if (ctx->lookup_pattern_binding (ref, &translated))
     {
+      TREE_USED (translated) = 1;
       return;
     }
   else
@@ -1371,6 +1375,11 @@ CompileExpr::visit (HIR::IdentifierExpr &expr)
       else
 	translated = CompileItem::compile (resolved_item, ctx, lookup, true,
 					   expr.get_locus ());
+
+      if (translated != error_mark_node)
+	{
+	  TREE_USED (translated) = 1;
+	}
     }
 }
 

gcc/rust/backend/rust-compile-item.cc

@@ -73,6 +73,10 @@ CompileItem::visit (HIR::StaticItem &var)
 void
 CompileItem::visit (HIR::ConstantItem &constant)
 {
+  if (ctx->lookup_const_decl (constant.get_mappings ().get_hirid (),
+			      &reference))
+    return;
+
   // resolve the type
   TyTy::BaseType *resolved_type = nullptr;
   bool ok

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

gcc/rust/backend/rust-compile-stmt.h

@@ -81,6 +81,7 @@ class CompileStmt : public HIRCompileBase, public HIR::HIRStmtVisitor
     bool ok = ctx->get_tyctx ()->lookup_type (
       stmt.get_init_expr ()->get_mappings ().get_hirid (), &actual);
     rust_assert (ok);
+    tree stmt_type = TyTyResolveCompile::compile (ctx, ty);
 
     Location lvalue_locus = stmt.get_pattern ()->get_locus ();
     Location rvalue_locus = stmt.get_init_expr ()->get_locus ();
@@ -90,8 +91,14 @@ class CompileStmt : public HIRCompileBase, public HIR::HIRStmtVisitor
     auto fnctx = ctx->peek_fn ();
     if (ty->is_unit ())
       {
-	// FIXME this feels wrong
 	ctx->add_statement (init);
+
+	auto unit_type_init_expr
+	  = ctx->get_backend ()->constructor_expression (stmt_type, false, {},
+							 -1, rvalue_locus);
+	auto s = ctx->get_backend ()->init_statement (fnctx.fndecl, var,
+						      unit_type_init_expr);
+	ctx->add_statement (s);
       }
     else
       {

gcc/rust/backend/rust-compile-tyty.h

@@ -54,10 +54,10 @@ class TyTyCompile : public TyTy::TyVisitor
 
   void visit (TyTy::TupleType &type) override
   {
-    if (type.num_fields () == 0)
-      translated = backend->unit_type ();
-    else
-      gcc_unreachable ();
+    // this interface is only for unit-type the -type interface takes into
+    // account the context
+    rust_assert (type.num_fields () == 0);
+    translated = backend->unit_type ();
   }
 
   void visit (TyTy::ArrayType &) override { gcc_unreachable (); }

gcc/rust/lang.opt

@@ -38,6 +38,18 @@ Wall
 Rust
 ; Documented in c.opt
 
+Wunused-variable
+Rust Var(warn_unused_variable) Init(1) Warning
+; documented in common.opt
+
+Wunused-const-variable
+Rust Warning Alias(Wunused-const-variable=, 2, 0)
+Warn when a const variable is unused.
+
+Wunused-const-variable=
+Rust Joined RejectNegative UInteger Var(warn_unused_const_variable) Init(1) Warning LangEnabledBy(Rust,Wunused-variable, 1, 0) IntegerRange(0, 2)
+Warn when a const variable is unused.
+
 Wunused-result
 Rust Var(warn_unused_result) Init(1) Warning
 Warn if a caller of a function, marked with attribute warn_unused_result, does not use its return value.

gcc/rust/lint/rust-lint-marklive.h

@@ -262,6 +262,12 @@ class MarkLive : public MarkLiveBase
     stct.get_struct_base ()->base_struct->accept_vis (*this);
   }
 
+  void visit (HIR::Module &module) override
+  {
+    for (auto &item : module.get_items ())
+      item->accept_vis (*this);
+  }
+
 private:
   std::vector<HirId> worklist;
   std::set<HirId> liveSymbols;

gcc/rust/lint/rust-lint-scan-deadcode.h

@@ -81,9 +81,11 @@ class ScanDeadcode : public MarkLiveBase
     HirId hirId = stct.get_mappings ().get_hirid ();
     if (should_warn (hirId))
       {
-	rust_warning_at (stct.get_locus (), 0,
-			 "struct is never constructed: %<%s%>",
-			 stct.get_identifier ().c_str ());
+	bool name_starts_underscore = stct.get_identifier ().at (0) == '_';
+	if (!name_starts_underscore)
+	  rust_warning_at (stct.get_locus (), 0,
+			   "struct is never constructed: %<%s%>",
+			   stct.get_identifier ().c_str ());
       }
     else
       {
@@ -124,6 +126,12 @@ class ScanDeadcode : public MarkLiveBase
       }
   }
 
+  void visit (HIR::Module &mod) override
+  {
+    for (auto &item : mod.get_items ())
+      item->accept_vis (*this);
+  }
+
 private:
   std::set<HirId> live_symbols;
   Resolver::Resolver *resolver;