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