Add support compound assignment operator overloads

Fixes #249

Author: philberty

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

@@ -135,6 +135,121 @@ CompileExpr::visit (HIR::ArithmeticOrLogicalExpr &expr)
 					    nullptr, expr.get_locus ());
 }
 
+void
+CompileExpr::visit (HIR::CompoundAssignmentExpr &expr)
+{
+  fncontext fn = ctx->peek_fn ();
+
+  auto op = expr.get_expr_type ();
+  auto lhs = CompileExpr::Compile (expr.get_left_expr ().get (), ctx);
+  auto rhs = CompileExpr::Compile (expr.get_right_expr ().get (), ctx);
+
+  // this might be an operator overload situation lets check
+  TyTy::FnType *fntype;
+  bool is_op_overload = ctx->get_tyctx ()->lookup_operator_overload (
+    expr.get_mappings ().get_hirid (), &fntype);
+  if (!is_op_overload)
+    {
+      auto operator_expr
+	= ctx->get_backend ()->arithmetic_or_logical_expression (
+	  op, lhs, rhs, expr.get_locus ());
+      Bstatement *assignment
+	= ctx->get_backend ()->assignment_statement (fn.fndecl, lhs,
+						     operator_expr,
+						     expr.get_locus ());
+      ctx->add_statement (assignment);
+      return;
+    }
+
+  // lookup the resolved name
+  NodeId resolved_node_id = UNKNOWN_NODEID;
+  if (!ctx->get_resolver ()->lookup_resolved_name (
+	expr.get_mappings ().get_nodeid (), &resolved_node_id))
+    {
+      rust_error_at (expr.get_locus (), "failed to lookup resolved MethodCall");
+      return;
+    }
+
+  // reverse lookup
+  HirId ref;
+  if (!ctx->get_mappings ()->lookup_node_to_hir (
+	expr.get_mappings ().get_crate_num (), resolved_node_id, &ref))
+    {
+      rust_fatal_error (expr.get_locus (), "reverse lookup failure");
+      return;
+    }
+
+  TyTy::BaseType *receiver = nullptr;
+  bool ok
+    = ctx->get_tyctx ()->lookup_receiver (expr.get_mappings ().get_hirid (),
+					  &receiver);
+  rust_assert (ok);
+
+  bool is_dyn_dispatch
+    = receiver->get_root ()->get_kind () == TyTy::TypeKind::DYNAMIC;
+  bool is_generic_receiver = receiver->get_kind () == TyTy::TypeKind::PARAM;
+  if (is_generic_receiver)
+    {
+      TyTy::ParamType *p = static_cast<TyTy::ParamType *> (receiver);
+      receiver = p->resolve ();
+    }
+
+  if (is_dyn_dispatch)
+    {
+      const TyTy::DynamicObjectType *dyn
+	= static_cast<const TyTy::DynamicObjectType *> (receiver->get_root ());
+
+      std::vector<HIR::Expr *> arguments;
+      arguments.push_back (expr.get_right_expr ().get ());
+
+      translated = compile_dyn_dispatch_call (dyn, receiver, fntype, lhs,
+					      arguments, expr.get_locus ());
+      return;
+    }
+
+  // lookup compiled functions since it may have already been compiled
+  HIR::PathIdentSegment segment_name ("add_assign");
+  Bexpression *fn_expr
+    = resolve_method_address (fntype, ref, receiver, segment_name,
+			      expr.get_mappings (), expr.get_locus ());
+
+  // lookup the autoderef mappings
+  std::vector<Resolver::Adjustment> *adjustments = nullptr;
+  ok = ctx->get_tyctx ()->lookup_autoderef_mappings (
+    expr.get_mappings ().get_hirid (), &adjustments);
+  rust_assert (ok);
+
+  Bexpression *self = lhs;
+  for (auto &adjustment : *adjustments)
+    {
+      switch (adjustment.get_type ())
+	{
+	case Resolver::Adjustment::AdjustmentType::IMM_REF:
+	case Resolver::Adjustment::AdjustmentType::MUT_REF:
+	  self = ctx->get_backend ()->address_expression (
+	    self, expr.get_left_expr ()->get_locus ());
+	  break;
+
+	case Resolver::Adjustment::AdjustmentType::DEREF_REF:
+	  Btype *expected_type
+	    = TyTyResolveCompile::compile (ctx, adjustment.get_expected ());
+	  self = ctx->get_backend ()->indirect_expression (
+	    expected_type, self, true, /* known_valid*/
+	    expr.get_left_expr ()->get_locus ());
+	  break;
+	}
+    }
+
+  std::vector<Bexpression *> args;
+  args.push_back (self); // adjusted self
+  args.push_back (rhs);
+
+  auto fncontext = ctx->peek_fn ();
+  translated
+    = ctx->get_backend ()->call_expression (fncontext.fndecl, fn_expr, args,
+					    nullptr, expr.get_locus ());
+}
+
 Bexpression *
 CompileExpr::compile_dyn_dispatch_call (const TyTy::DynamicObjectType *dyn,
 					TyTy::BaseType *receiver,

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

@@ -388,22 +388,7 @@ class CompileExpr : public HIRCompileBase
     ctx->add_statement (assignment);
   }
 
-  void visit (HIR::CompoundAssignmentExpr &expr) override
-  {
-    fncontext fn = ctx->peek_fn ();
-    auto lvalue = CompileExpr::Compile (expr.get_left_expr ().get (), ctx);
-    auto rvalue = CompileExpr::Compile (expr.get_right_expr ().get (), ctx);
-
-    auto op = expr.get_expr_type ();
-    auto operator_expr = ctx->get_backend ()->arithmetic_or_logical_expression (
-      op, lvalue, rvalue, expr.get_locus ());
-
-    Bstatement *assignment
-      = ctx->get_backend ()->assignment_statement (fn.fndecl, lvalue,
-						   operator_expr,
-						   expr.get_locus ());
-    ctx->add_statement (assignment);
-  }
+  void visit (HIR::CompoundAssignmentExpr &expr) override;
 
   void visit (HIR::ArrayIndexExpr &expr) override
   {

gcc/rust/typecheck/rust-autoderef.h

@@ -68,6 +68,47 @@ class Adjustment
   const TyTy::BaseType *expected;
 };
 
+class Adjuster
+{
+public:
+  Adjuster (const TyTy::BaseType *ty) : base (ty) {}
+
+  TyTy::BaseType *adjust_type (std::vector<Adjustment> adjustments)
+  {
+    TyTy::BaseType *ty = base->clone ();
+    for (auto &adjustment : adjustments)
+      {
+	switch (adjustment.get_type ())
+	  {
+	  case Resolver::Adjustment::AdjustmentType::IMM_REF:
+	    ty = new TyTy::ReferenceType (ty->get_ref (),
+					  TyTy::TyVar (ty->get_ref ()),
+					  Mutability::Imm);
+	    break;
+
+	  case Resolver::Adjustment::AdjustmentType::MUT_REF:
+	    ty = new TyTy::ReferenceType (ty->get_ref (),
+					  TyTy::TyVar (ty->get_ref ()),
+					  Mutability::Mut);
+	    break;
+
+	  case Resolver::Adjustment::AdjustmentType::DEREF_REF:
+	    // FIXME this really needs to support deref lang-item operator
+	    // overloads
+	    rust_assert (ty->get_kind () == TyTy::TypeKind::REF);
+	    const TyTy::ReferenceType *rr
+	      = static_cast<const TyTy::ReferenceType *> (ty);
+	    ty = rr->get_base ();
+	    break;
+	  }
+      }
+    return ty;
+  }
+
+private:
+  const TyTy::BaseType *base;
+};
+
 } // namespace Resolver
 } // namespace Rust