Add in TupleStruct support

This adds in tuple struct support with name and type resolution. The
arguments and number of arguments are validated against. Test cases
added for those errors too.

5 files changed, 75 insertions, 52 deletions

diff --git a/gcc/rust/backend/rust-compile-expr.h b/gcc/rust/backend/rust-compile-expr.h
index 98e8ee1..8b99574 100644
--- a/gcc/rust/backend/rust-compile-expr.h
+++ b/gcc/rust/backend/rust-compile-expr.h
@@ -86,24 +86,7 @@ public:
     ctx->add_statement (s);
   }
 
-  void visit (HIR::CallExpr &expr)
-  {
-    Bexpression *fn = ResolvePathRef::Compile (expr.get_fnexpr (), ctx);
-    rust_assert (fn != nullptr);
-
-    std::vector<Bexpression *> args;
-    expr.iterate_params ([&] (HIR::Expr *p) mutable -> bool {
-      Bexpression *compiled_expr = CompileExpr::Compile (p, ctx);
-      rust_assert (compiled_expr != nullptr);
-      args.push_back (compiled_expr);
-      return true;
-    });
-
-    auto fncontext = ctx->peek_fn ();
-    translated
-      = ctx->get_backend ()->call_expression (fncontext.fndecl, fn, args,
-					      nullptr, expr.get_locus ());
-  }
+  void visit (HIR::CallExpr &expr);
 
   void visit (HIR::IdentifierExpr &expr)
   {
diff --git a/gcc/rust/backend/rust-compile-item.h b/gcc/rust/backend/rust-compile-item.h
index a367ac7..c8cffc7 100644
--- a/gcc/rust/backend/rust-compile-item.h
+++ b/gcc/rust/backend/rust-compile-item.h
@@ -37,35 +37,32 @@ public:
     item->accept_vis (compiler);
   }
 
-  virtual ~CompileItem () {}
-
-  void visit (HIR::StructStruct &struct_decl)
+  void visit (HIR::TupleStruct &struct_decl)
   {
-    std::vector<Backend::Btyped_identifier> fields;
-    struct_decl.iterate ([&] (HIR::StructField &field) mutable -> bool {
-      TyTy::TyBase *resolved_type = nullptr;
-      bool ok
-	= ctx->get_tyctx ()->lookup_type (field.get_mappings ().get_hirid (),
-					  &resolved_type);
-      rust_assert (ok);
+    TyTy::TyBase *resolved = nullptr;
+    if (!ctx->get_tyctx ()->lookup_type (
+	  struct_decl.get_mappings ().get_hirid (), &resolved))
+      {
+	rust_fatal_error (struct_decl.get_locus (),
+			  "Failed to lookup type for struct decl");
+	return;
+      }
 
-      Btype *compiled_field_ty
-	= TyTyCompile::compile (ctx->get_backend (), resolved_type);
+    TyTyResolveCompile::compile (ctx, resolved);
+  }
 
-      Backend::Btyped_identifier f (field.field_name, compiled_field_ty,
-				    field.get_locus ());
-      fields.push_back (std::move (f));
-      return true;
-    });
+  void visit (HIR::StructStruct &struct_decl)
+  {
+    TyTy::TyBase *resolved = nullptr;
+    if (!ctx->get_tyctx ()->lookup_type (
+	  struct_decl.get_mappings ().get_hirid (), &resolved))
+      {
+	rust_fatal_error (struct_decl.get_locus (),
+			  "Failed to lookup type for struct decl");
+	return;
+      }
 
-    Btype *struct_type_record = ctx->get_backend ()->struct_type (fields);
-    Btype *named_struct
-      = ctx->get_backend ()->named_type (struct_decl.get_identifier (),
-					 struct_type_record,
-					 struct_decl.get_locus ());
-    ctx->push_type (named_struct);
-    ctx->insert_compiled_type (struct_decl.get_mappings ().get_hirid (),
-			       named_struct);
+    TyTyResolveCompile::compile (ctx, resolved);
   }
 
   void visit (HIR::StaticItem &var)
diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc
index 374f8a0..37285b7 100644
--- a/gcc/rust/backend/rust-compile-resolve-path.cc
+++ b/gcc/rust/backend/rust-compile-resolve-path.cc
@@ -32,7 +32,6 @@ ResolvePathRef::visit (HIR::PathInExpression &expr)
   if (!ctx->get_resolver ()->lookup_resolved_name (
 	expr.get_mappings ().get_nodeid (), &ref_node_id))
     {
-      rust_fatal_error (expr.get_locus (), "failed to look up resolved name");
       return;
     }
 
@@ -40,7 +39,7 @@ ResolvePathRef::visit (HIR::PathInExpression &expr)
   if (!ctx->get_mappings ()->lookup_node_to_hir (
 	expr.get_mappings ().get_crate_num (), ref_node_id, &ref))
     {
-      rust_fatal_error (expr.get_locus (), "reverse lookup failure");
+      rust_error_at (expr.get_locus (), "reverse lookup failure");
       return;
     }
 
@@ -54,14 +53,14 @@ ResolvePathRef::visit (HIR::PathInExpression &expr)
 	expr.get_mappings ().get_crate_num (), ref);
       if (resolved_item == nullptr)
 	{
-	  rust_fatal_error (expr.get_locus (), "failed to lookup forward decl");
+	  rust_error_at (expr.get_locus (), "failed to lookup forward decl");
 	  return;
 	}
 
       CompileItem::compile (resolved_item, ctx);
       if (!ctx->lookup_function_decl (ref, &fn))
 	{
-	  rust_fatal_error (expr.get_locus (), "forward decl was not compiled");
+	  rust_error_at (expr.get_locus (), "forward decl was not compiled");
 	  return;
 	}
     }
@@ -78,7 +77,6 @@ ResolvePathType::visit (HIR::PathInExpression &expr)
   if (!ctx->get_resolver ()->lookup_resolved_type (
 	expr.get_mappings ().get_nodeid (), &ref_node_id))
     {
-      rust_fatal_error (expr.get_locus (), "failed to look up resolved name");
       return;
     }
 
@@ -86,14 +84,14 @@ ResolvePathType::visit (HIR::PathInExpression &expr)
   if (!ctx->get_mappings ()->lookup_node_to_hir (
 	expr.get_mappings ().get_crate_num (), ref_node_id, &ref))
     {
-      rust_fatal_error (expr.get_locus (), "reverse lookup failure");
+      rust_error_at (expr.get_locus (), "reverse lookup failure");
       return;
     }
 
   // assumes paths are functions for now
   if (!ctx->lookup_compiled_types (ref, &resolved))
     {
-      rust_fatal_error (expr.get_locus (), "forward decl was not compiled");
+      rust_error_at (expr.get_locus (), "forward decl was not compiled");
       return;
     }
 }
diff --git a/gcc/rust/backend/rust-compile-resolve-path.h b/gcc/rust/backend/rust-compile-resolve-path.h
index a5543d2..2f3cb68 100644
--- a/gcc/rust/backend/rust-compile-resolve-path.h
+++ b/gcc/rust/backend/rust-compile-resolve-path.h
@@ -32,7 +32,6 @@ public:
   {
     ResolvePathRef resolver (ctx);
     expr->accept_vis (resolver);
-    rust_assert (resolver.resolved != nullptr);
     return resolver.resolved;
   }
 
@@ -51,7 +50,6 @@ public:
   {
     ResolvePathType resolver (ctx);
     expr->accept_vis (resolver);
-    rust_assert (resolver.resolved != nullptr);
     return resolver.resolved;
   }
 
diff --git a/gcc/rust/backend/rust-compile.cc b/gcc/rust/backend/rust-compile.cc
index 772d975..6519a47 100644
--- a/gcc/rust/backend/rust-compile.cc
+++ b/gcc/rust/backend/rust-compile.cc
@@ -48,6 +48,53 @@ CompileCrate::go ()
     CompileItem::compile (item.get (), ctx, true);
 }
 
+// rust-compile-expr.h
+
+void
+CompileExpr::visit (HIR::CallExpr &expr)
+{
+  // this can be a function call or it can be a constructor for a tuple struct
+  Bexpression *fn = ResolvePathRef::Compile (expr.get_fnexpr (), ctx);
+  if (fn != nullptr)
+    {
+      std::vector<Bexpression *> args;
+      expr.iterate_params ([&] (HIR::Expr *p) mutable -> bool {
+	Bexpression *compiled_expr = CompileExpr::Compile (p, ctx);
+	rust_assert (compiled_expr != nullptr);
+	args.push_back (compiled_expr);
+	return true;
+      });
+
+      auto fncontext = ctx->peek_fn ();
+      translated
+	= ctx->get_backend ()->call_expression (fncontext.fndecl, fn, args,
+						nullptr, expr.get_locus ());
+    }
+  else
+    {
+      Btype *type = ResolvePathType::Compile (expr.get_fnexpr (), ctx);
+      if (type == nullptr)
+	{
+	  rust_fatal_error (expr.get_locus (),
+			    "failed to lookup type associated with call");
+	  return;
+	}
+
+      // this assumes all fields are in order from type resolution and if a base
+      // struct was specified those fields are filed via accesors
+      std::vector<Bexpression *> vals;
+      expr.iterate_params ([&] (HIR::Expr *argument) mutable -> bool {
+	Bexpression *e = CompileExpr::Compile (argument, ctx);
+	vals.push_back (e);
+	return true;
+      });
+
+      translated
+	= ctx->get_backend ()->constructor_expression (type, vals,
+						       expr.get_locus ());
+    }
+}
+
 // rust-compile-block.h
 
 void