Merge #526

526: Add unit-type support for Identifier expressions r=philberty a=philberty

Unit type can be reference via an identifier expression. Other type references via an identifier expression are not supported yet.

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

8 files changed, 203 insertions, 78 deletions

diff --git a/gcc/rust/backend/rust-compile-expr.h b/gcc/rust/backend/rust-compile-expr.h
index 8391bc4..fc8ad81 100644
--- a/gcc/rust/backend/rust-compile-expr.h
+++ b/gcc/rust/backend/rust-compile-expr.h
@@ -109,32 +109,81 @@ public:
 
   void visit (HIR::IdentifierExpr &expr) override
   {
-    // need to look up the reference for this identifier
-    NodeId ref_node_id;
-    if (!ctx->get_resolver ()->lookup_resolved_name (
-	  expr.get_mappings ().get_nodeid (), &ref_node_id))
+    NodeId ast_node_id = expr.get_mappings ().get_nodeid ();
+
+    bool is_value = false;
+    NodeId ref_node_id = UNKNOWN_NODEID;
+    if (ctx->get_resolver ()->lookup_resolved_name (ast_node_id, &ref_node_id))
+      {
+	// these ref_node_ids will resolve to a pattern declaration but we are
+	// interested in the definition that this refers to get the parent id
+	Resolver::Definition def;
+	if (!ctx->get_resolver ()->lookup_definition (ref_node_id, &def))
+	  {
+	    rust_error_at (expr.get_locus (),
+			   "unknown reference for resolved name");
+	    return;
+	  }
+	ref_node_id = def.parent;
+	is_value = true;
+      }
+    else if (!ctx->get_resolver ()->lookup_resolved_type (ast_node_id,
+							  &ref_node_id))
       {
-	rust_fatal_error (expr.get_locus (), "failed to look up resolved name");
+	rust_error_at (expr.get_locus (),
+		       "Failed to lookup type reference for node: %s",
+		       expr.as_string ().c_str ());
 	return;
       }
 
-    // these ref_node_ids will resolve to a pattern declaration but we are
-    // interested in the definition that this refers to get the parent id
-    Resolver::Definition def;
-    if (!ctx->get_resolver ()->lookup_definition (ref_node_id, &def))
+    if (ref_node_id == UNKNOWN_NODEID)
       {
-	rust_error_at (expr.get_locus (), "unknown reference");
+	rust_fatal_error (expr.get_locus (), "unresolved IdentifierExpr: %s",
+			  expr.as_string ().c_str ());
 	return;
       }
 
+    // node back to HIR
     HirId ref;
     if (!ctx->get_mappings ()->lookup_node_to_hir (
-	  expr.get_mappings ().get_crate_num (), def.parent, &ref))
+	  expr.get_mappings ().get_crate_num (), ref_node_id, &ref))
+      {
+	rust_error_at (expr.get_locus (), "reverse lookup failure");
+	return;
+      }
+
+    TyTy::BaseType *lookup = nullptr;
+    if (!ctx->get_tyctx ()->lookup_type (ref, &lookup))
       {
-	rust_fatal_error (expr.get_locus (), "reverse lookup failure");
+	rust_fatal_error (expr.get_locus (),
+			  "failed to find type relevant to this context: %s",
+			  expr.get_mappings ().as_string ().c_str ());
 	return;
       }
 
+    bool is_type_ref = !is_value;
+    if (is_type_ref)
+      {
+	// this might be a case for
+	//
+	// struct S;
+	//
+	// fn main() {
+	//    let s = S;
+	// }
+
+	if (lookup->is_unit ())
+	  {
+	    translated = ctx->get_backend ()->unit_expression ();
+	    return;
+	  }
+
+	// rust actually treats like this an fn call or structs with fields but
+	// unit structs are just the struct name lets catch it with an is-unit
+	// check
+	gcc_unreachable ();
+      }
+
     Bfunction *fn = nullptr;
     Bvariable *var = nullptr;
     if (ctx->lookup_const_decl (ref, &translated))
@@ -478,6 +527,20 @@ public:
       }
   }
 
+  void visit (HIR::StructExprStruct &struct_expr) override
+  {
+    TyTy::BaseType *tyty = nullptr;
+    if (!ctx->get_tyctx ()->lookup_type (
+	  struct_expr.get_mappings ().get_hirid (), &tyty))
+      {
+	rust_error_at (struct_expr.get_locus (), "unknown type");
+	return;
+      }
+
+    rust_assert (tyty->is_unit ());
+    translated = ctx->get_backend ()->unit_expression ();
+  }
+
   void visit (HIR::StructExprStructFields &struct_expr) override
   {
     TyTy::BaseType *tyty = nullptr;
diff --git a/gcc/rust/hir/rust-ast-lower-expr.h b/gcc/rust/hir/rust-ast-lower-expr.h
index 82d13d0..19ce8c2 100644
--- a/gcc/rust/hir/rust-ast-lower-expr.h
+++ b/gcc/rust/hir/rust-ast-lower-expr.h
@@ -467,6 +467,24 @@ public:
 				 expr.get_locus ());
   }
 
+  void visit (AST::StructExprStruct &struct_expr) override
+  {
+    HIR::PathInExpression *path
+      = ASTLowerPathInExpression::translate (&struct_expr.get_struct_name ());
+    HIR::PathInExpression copied_path (*path);
+    delete path;
+
+    auto crate_num = mappings->get_current_crate ();
+    Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (),
+				   mappings->get_next_hir_id (crate_num),
+				   UNKNOWN_LOCAL_DEFID);
+
+    translated = new HIR::StructExprStruct (mapping, copied_path,
+					    struct_expr.get_inner_attrs (),
+					    struct_expr.get_outer_attrs (),
+					    struct_expr.get_locus ());
+  }
+
   void visit (AST::StructExprStructFields &struct_expr) override
   {
     // bit of a hack for now
diff --git a/gcc/rust/lint/rust-lint-marklive.cc b/gcc/rust/lint/rust-lint-marklive.cc
index 3bfc1c3..0d4963c 100644
--- a/gcc/rust/lint/rust-lint-marklive.cc
+++ b/gcc/rust/lint/rust-lint-marklive.cc
@@ -138,6 +138,13 @@ MarkLive::visit (HIR::IdentifierExpr &expr)
 	}
       ref_node_id = def.parent;
     }
+  else if (!resolver->lookup_resolved_type (ast_node_id, &ref_node_id))
+    {
+      rust_error_at (expr.get_locus (),
+		     "Failed to lookup type reference for node: %s",
+		     expr.as_string ().c_str ());
+      return;
+    }
 
   if (ref_node_id == UNKNOWN_NODEID)
     {
diff --git a/gcc/rust/resolve/rust-ast-resolve-expr.h b/gcc/rust/resolve/rust-ast-resolve-expr.h
index f163ef5b..bbd8818 100644
--- a/gcc/rust/resolve/rust-ast-resolve-expr.h
+++ b/gcc/rust/resolve/rust-ast-resolve-expr.h
@@ -219,6 +219,14 @@ public:
     ResolveExpr::go (elems.get_elem_to_copy ().get (), elems.get_node_id ());
   }
 
+  // this this an empty struct constructor like 'S {}'
+  void visit (AST::StructExprStruct &struct_expr) override
+  {
+    ResolveExpr::go (&struct_expr.get_struct_name (),
+		     struct_expr.get_node_id ());
+  }
+
+  // this this a struct constructor with fields
   void visit (AST::StructExprStructFields &struct_expr) override
   {
     ResolveExpr::go (&struct_expr.get_struct_name (),
diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.h b/gcc/rust/typecheck/rust-hir-type-check-expr.h
index 236c7b9..bdebfd3 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-expr.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-expr.h
@@ -827,6 +827,21 @@ public:
       = TypeCheckExpr::Resolve (elems.get_elem_to_copy (), false);
   }
 
+  // empty struct
+  void visit (HIR::StructExprStruct &struct_expr) override
+  {
+    TyTy::BaseType *struct_path_ty
+      = TypeCheckExpr::Resolve (&struct_expr.get_struct_name (), false);
+    if (struct_path_ty->get_kind () != TyTy::TypeKind::ADT)
+      {
+	rust_error_at (struct_expr.get_struct_name ().get_locus (),
+		       "expected an ADT type for constructor");
+	return;
+      }
+
+    infered = struct_path_ty;
+  }
+
   void visit (HIR::StructExprStructFields &struct_expr) override
   {
     infered = TypeCheckStructExpr::Resolve (&struct_expr);
diff --git a/gcc/rust/typecheck/rust-tyty.h b/gcc/rust/typecheck/rust-tyty.h
index fcf4d86..51ede17 100644
--- a/gcc/rust/typecheck/rust-tyty.h
+++ b/gcc/rust/typecheck/rust-tyty.h
@@ -52,6 +52,71 @@ enum TypeKind
   ERROR
 };
 
+class TypeKindFormat
+{
+public:
+  static std::string to_string (TypeKind kind)
+  {
+    switch (kind)
+      {
+      case TypeKind::INFER:
+	return "Infer";
+
+      case TypeKind::ADT:
+	return "ADT";
+
+      case TypeKind::STR:
+	return "STR";
+
+      case TypeKind::REF:
+	return "REF";
+
+      case TypeKind::PARAM:
+	return "PARAM";
+
+      case TypeKind::ARRAY:
+	return "ARRAY";
+
+      case TypeKind::FNDEF:
+	return "FnDef";
+
+      case TypeKind::FNPTR:
+	return "FnPtr";
+
+      case TypeKind::TUPLE:
+	return "Tuple";
+
+      case TypeKind::BOOL:
+	return "Bool";
+
+      case TypeKind::CHAR:
+	return "Char";
+
+      case TypeKind::INT:
+	return "Int";
+
+      case TypeKind::UINT:
+	return "Uint";
+
+      case TypeKind::FLOAT:
+	return "Float";
+
+      case TypeKind::USIZE:
+	return "Usize";
+
+      case TypeKind::ISIZE:
+	return "Isize";
+
+      case TypeKind::NEVER:
+	return "Never";
+
+      case TypeKind::ERROR:
+	return "ERROR";
+      }
+    gcc_unreachable ();
+  }
+};
+
 class TyVisitor;
 class BaseType
 {
@@ -138,7 +203,8 @@ public:
 
   std::string debug_str () const
   {
-    return as_string () + ":" + mappings_str ();
+    return TypeKindFormat::to_string (get_kind ()) + ":" + as_string () + ":"
+	   + mappings_str ();
   }
 
   void debug () const
@@ -777,6 +843,8 @@ public:
 
   bool get_is_tuple () { return is_tuple; }
 
+  bool is_unit () const override { return this->fields.empty (); }
+
   void accept_vis (TyVisitor &vis) override;
 
   std::string as_string () const override;
@@ -1407,71 +1475,6 @@ public:
   bool is_unit () const override { return true; }
 };
 
-class TypeKindFormat
-{
-public:
-  static std::string to_string (TypeKind kind)
-  {
-    switch (kind)
-      {
-      case TypeKind::INFER:
-	return "Infer";
-
-      case TypeKind::ADT:
-	return "ADT";
-
-      case TypeKind::STR:
-	return "STR";
-
-      case TypeKind::REF:
-	return "REF";
-
-      case TypeKind::PARAM:
-	return "PARAM";
-
-      case TypeKind::ARRAY:
-	return "ARRAY";
-
-      case TypeKind::FNDEF:
-	return "FnDef";
-
-      case TypeKind::FNPTR:
-	return "FnPtr";
-
-      case TypeKind::TUPLE:
-	return "Tuple";
-
-      case TypeKind::BOOL:
-	return "Bool";
-
-      case TypeKind::CHAR:
-	return "Char";
-
-      case TypeKind::INT:
-	return "Int";
-
-      case TypeKind::UINT:
-	return "Uint";
-
-      case TypeKind::FLOAT:
-	return "Float";
-
-      case TypeKind::USIZE:
-	return "Usize";
-
-      case TypeKind::ISIZE:
-	return "Isize";
-
-      case TypeKind::NEVER:
-	return "Never";
-
-      case TypeKind::ERROR:
-	return "ERROR";
-      }
-    gcc_unreachable ();
-  }
-};
-
 } // namespace TyTy
 } // namespace Rust
 
diff --git a/gcc/testsuite/rust/compile/torture/unit_type3.rs b/gcc/testsuite/rust/compile/torture/unit_type3.rs
new file mode 100644
index 0000000..d48a691
--- /dev/null
+++ b/gcc/testsuite/rust/compile/torture/unit_type3.rs
@@ -0,0 +1,6 @@
+struct S;
+
+fn main() {
+    let s = S;
+    // { dg-warning "unused name" "" { target *-*-* } .-1 }
+}
diff --git a/gcc/testsuite/rust/compile/torture/unit_type4.rs b/gcc/testsuite/rust/compile/torture/unit_type4.rs
new file mode 100644
index 0000000..ccbfa21
--- /dev/null
+++ b/gcc/testsuite/rust/compile/torture/unit_type4.rs
@@ -0,0 +1,5 @@
+struct S;
+
+fn main() {
+    let _s = S {};
+}