First stab at operator overloading

When no built-in interpretation is found for one of the operators
mentioned below, the typechecker will try to turn it into a method
call with the name written next to it. For binary operators, the
method will be called on the LHS with the RHS as only parameter.

Binary:

    +   op_add
    -   op_sub
    *   op_mul
    /   op_div
    %   op_rem
    &   op_and
    |   op_or
    ^   op_xor
    <<  op_shift_left
    >>  op_shift_right
    >>> op_ashift_right

Unary:

    -   op_neg
    !   op_not

Overloading of the indexing ([]) operator isn't finished yet.

Issue #1520

Author: marijnh

src/comp/driver/driver.rs

@@ -162,12 +162,12 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
     let freevars =
         time(time_passes, "freevar finding",
              bind freevars::annotate_freevars(def_map, crate));
-    time(time_passes, "const checking",
-         bind middle::check_const::check_crate(sess, crate));
     let ty_cx = ty::mk_ctxt(sess, def_map, ast_map, freevars);
     let (method_map, dict_map) =
         time(time_passes, "typechecking",
              bind typeck::check_crate(ty_cx, impl_map, crate));
+    time(time_passes, "const checking",
+         bind middle::check_const::check_crate(sess, crate, method_map));
 
     if upto == cu_typeck { ret {crate: crate, tcx: some(ty_cx)}; }
 

src/comp/middle/check_const.rs

@@ -2,11 +2,11 @@ import syntax::ast::*;
 import syntax::{visit, ast_util};
 import driver::session::session;
 
-fn check_crate(sess: session, crate: @crate) {
+fn check_crate(sess: session, crate: @crate, method_map: typeck::method_map) {
     visit::visit_crate(*crate, false, visit::mk_vt(@{
         visit_item: check_item,
         visit_pat: check_pat,
-        visit_expr: bind check_expr(sess, _, _, _)
+        visit_expr: bind check_expr(sess, method_map, _, _, _)
         with *visit::default_visitor()
     }));
     sess.abort_if_errors();
@@ -41,7 +41,8 @@ fn check_pat(p: @pat, &&_is_const: bool, v: visit::vt<bool>) {
     }
 }
 
-fn check_expr(sess: session, e: @expr, &&is_const: bool, v: visit::vt<bool>) {
+fn check_expr(sess: session, method_map: typeck::method_map, e: @expr,
+              &&is_const: bool, v: visit::vt<bool>) {
     if is_const {
         alt e.node {
           expr_unary(box(_), _) | expr_unary(uniq(_), _) |
@@ -54,7 +55,13 @@ fn check_expr(sess: session, e: @expr, &&is_const: bool, v: visit::vt<bool>) {
             sess.span_err(e.span,
                           "string constants are not supported");
           }
-          expr_lit(_) | expr_binary(_, _, _) | expr_unary(_, _) {}
+          expr_binary(_, _, _) | expr_unary(_, _) {
+            if method_map.contains_key(e.id) {
+                sess.span_err(e.span, "user-defined operators are not \
+                                       allowed in constant expressions");
+            }
+          }
+          expr_lit(_) {}
           _ {
             sess.span_err(e.span,
                           "constant contains unimplemented expression type");

src/comp/middle/resolve.rs

@@ -1983,9 +1983,9 @@ fn visit_mod_with_impl_scope(e: @env, m: ast::_mod, s: span, sc: iscopes,
 
 fn resolve_impl_in_expr(e: @env, x: @ast::expr, sc: iscopes, v: vt<iscopes>) {
     alt x.node {
-      ast::expr_field(_, _, _) | ast::expr_path(_) | ast::expr_cast(_, _) {
-        e.impl_map.insert(x.id, sc);
-      }
+      ast::expr_field(_, _, _) | ast::expr_path(_) | ast::expr_cast(_, _) |
+      ast::expr_binary(_, _, _) | ast::expr_unary(_, _) |
+      ast::expr_assign_op(_, _, _) { e.impl_map.insert(x.id, sc); }
       _ {}
     }
     visit::visit_expr(x, sc, v);

src/comp/middle/trans.rs

@@ -2072,7 +2072,19 @@ fn node_type(cx: @crate_ctxt, sp: span, id: ast::node_id) -> TypeRef {
 }
 
 fn trans_unary(bcx: @block_ctxt, op: ast::unop, e: @ast::expr,
-               id: ast::node_id, dest: dest) -> @block_ctxt {
+               un_expr: @ast::expr, dest: dest) -> @block_ctxt {
+    // Check for user-defined method call
+    alt bcx_ccx(bcx).method_map.find(un_expr.id) {
+      some(origin) {
+        let callee_id = ast_util::op_expr_callee_id(un_expr);
+        let fty = ty::node_id_to_monotype(bcx_tcx(bcx), callee_id);
+        ret trans_call_inner(bcx, fty, {|bcx|
+            trans_impl::trans_method_callee(bcx, callee_id, e, origin)
+        }, [], un_expr.id, dest);
+      }
+      _ {}
+    }
+
     if dest == ignore { ret trans_expr(bcx, e, ignore); }
     let e_ty = ty::expr_ty(bcx_tcx(bcx), e);
     alt op {
@@ -2104,7 +2116,7 @@ fn trans_unary(bcx: @block_ctxt, op: ast::unop, e: @ast::expr,
         ret store_in_dest(bcx, box, dest);
       }
       ast::uniq(_) {
-        ret trans_uniq::trans_uniq(bcx, e, id, dest);
+        ret trans_uniq::trans_uniq(bcx, e, un_expr.id, dest);
       }
       ast::deref {
         bcx_ccx(bcx).sess.bug("deref expressions should have been \
@@ -2193,12 +2205,26 @@ fn trans_eager_binop(cx: @block_ctxt, op: ast::binop, lhs: ValueRef,
     ret store_in_dest(cx, val, dest);
 }
 
-fn trans_assign_op(bcx: @block_ctxt, op: ast::binop, dst: @ast::expr,
-                   src: @ast::expr) -> @block_ctxt {
+fn trans_assign_op(bcx: @block_ctxt, ex: @ast::expr, op: ast::binop,
+                   dst: @ast::expr, src: @ast::expr) -> @block_ctxt {
     let tcx = bcx_tcx(bcx);
     let t = ty::expr_ty(tcx, src);
     let lhs_res = trans_lval(bcx, dst);
     assert (lhs_res.kind == owned);
+
+    // A user-defined operator method
+    alt bcx_ccx(bcx).method_map.find(ex.id) {
+      some(origin) {
+        let callee_id = ast_util::op_expr_callee_id(ex);
+        let fty = ty::node_id_to_monotype(bcx_tcx(bcx), callee_id);
+        ret trans_call_inner(bcx, fty, {|bcx|
+            // FIXME provide the already-computed address, not the expr
+            trans_impl::trans_method_callee(bcx, callee_id, src, origin)
+        }, [dst], ex.id, save_in(lhs_res.val));
+      }
+      _ {}
+    }
+
     // Special case for `+= [x]`
     alt ty::struct(tcx, t) {
       ty::ty_vec(_) {
@@ -2305,20 +2331,34 @@ fn trans_lazy_binop(bcx: @block_ctxt, op: ast::binop, a: @ast::expr,
     ret store_in_dest(join_cx, phi, dest);
 }
 
-fn trans_binary(cx: @block_ctxt, op: ast::binop, a: @ast::expr, b: @ast::expr,
-                dest: dest) -> @block_ctxt {
+
+
+fn trans_binary(bcx: @block_ctxt, op: ast::binop, a: @ast::expr,
+                b: @ast::expr, dest: dest, ex: @ast::expr) -> @block_ctxt {
+    // User-defined operators
+    alt bcx_ccx(bcx).method_map.find(ex.id) {
+      some(origin) {
+        let callee_id = ast_util::op_expr_callee_id(ex);
+        let fty = ty::node_id_to_monotype(bcx_tcx(bcx), callee_id);
+        ret trans_call_inner(bcx, fty, {|bcx|
+            trans_impl::trans_method_callee(bcx, callee_id, a, origin)
+        }, [b], ex.id, dest);
+      }
+      _ {}
+    }
+
     // First couple cases are lazy:
     alt op {
       ast::and | ast::or {
-        ret trans_lazy_binop(cx, op, a, b, dest);
+        ret trans_lazy_binop(bcx, op, a, b, dest);
       }
       _ {
         // Remaining cases are eager:
-        let lhs = trans_temp_expr(cx, a);
+        let lhs = trans_temp_expr(bcx, a);
         let rhs = trans_temp_expr(lhs.bcx, b);
         ret trans_eager_binop(rhs.bcx, op, lhs.val,
-                              ty::expr_ty(bcx_tcx(cx), a), rhs.val,
-                              ty::expr_ty(bcx_tcx(cx), b), dest);
+                              ty::expr_ty(bcx_tcx(bcx), a), rhs.val,
+                              ty::expr_ty(bcx_tcx(bcx), b), dest);
       }
     }
 }
@@ -2746,15 +2786,8 @@ fn trans_callee(bcx: @block_ctxt, e: @ast::expr) -> lval_maybe_callee {
         // Lval means this is a record field, so not a method
         if !expr_is_lval(bcx, e) {
             alt bcx_ccx(bcx).method_map.find(e.id) {
-              some(typeck::method_static(did)) { // An impl method
-                ret trans_impl::trans_static_callee(bcx, e, base, did);
-              }
-              some(typeck::method_param(iid, off, p, b)) {
-                ret trans_impl::trans_param_callee(
-                    bcx, e, base, iid, off, p, b);
-              }
-              some(typeck::method_iface(off)) {
-                ret trans_impl::trans_iface_callee(bcx, e, base, off);
+              some(origin) { // An impl method
+                ret trans_impl::trans_method_callee(bcx, e.id, base, origin);
               }
             }
         }
@@ -3132,15 +3165,22 @@ fn trans_args(cx: @block_ctxt, llenv: ValueRef,
 fn trans_call(in_cx: @block_ctxt, f: @ast::expr,
               args: [@ast::expr], id: ast::node_id, dest: dest)
     -> @block_ctxt {
+    trans_call_inner(in_cx, ty::expr_ty(bcx_tcx(in_cx), f),
+                     {|cx| trans_callee(cx, f)}, args, id, dest)
+}
+
+fn trans_call_inner(in_cx: @block_ctxt, fn_expr_ty: ty::t,
+                    get_callee: fn(@block_ctxt) -> lval_maybe_callee,
+                    args: [@ast::expr], id: ast::node_id, dest: dest)
+    -> @block_ctxt {
     // NB: 'f' isn't necessarily a function; it might be an entire self-call
     // expression because of the hack that allows us to process self-calls
     // with trans_call.
     let tcx = bcx_tcx(in_cx);
-    let fn_expr_ty = ty::expr_ty(tcx, f);
 
     let cx = new_scope_block_ctxt(in_cx, "call");
     Br(in_cx, cx.llbb);
-    let f_res = trans_callee(cx, f);
+    let f_res = get_callee(cx);
     let bcx = f_res.bcx;
 
     let faddr = f_res.val;
@@ -3478,10 +3518,12 @@ fn trans_expr(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt {
       ast::expr_tup(args) { ret trans_tup(bcx, args, e.id, dest); }
       ast::expr_lit(lit) { ret trans_lit(bcx, *lit, dest); }
       ast::expr_vec(args, _) { ret tvec::trans_vec(bcx, args, e.id, dest); }
-      ast::expr_binary(op, x, y) { ret trans_binary(bcx, op, x, y, dest); }
+      ast::expr_binary(op, x, y) {
+        ret trans_binary(bcx, op, x, y, dest, e);
+      }
       ast::expr_unary(op, x) {
         assert op != ast::deref; // lvals are handled above
-        ret trans_unary(bcx, op, x, e.id, dest);
+        ret trans_unary(bcx, op, x, e, dest);
       }
       ast::expr_fn(proto, decl, body, cap_clause) {
         ret trans_closure::trans_expr_fn(
@@ -3620,7 +3662,7 @@ fn trans_expr(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt {
       }
       ast::expr_assign_op(op, dst, src) {
         assert dest == ignore;
-        ret trans_assign_op(bcx, op, dst, src);
+        ret trans_assign_op(bcx, e, op, dst, src);
       }
     }
 }

src/comp/middle/trans_impl.rs

@@ -62,11 +62,28 @@ fn trans_self_arg(bcx: @block_ctxt, base: @ast::expr) -> result {
     rslt(bcx, PointerCast(bcx, val, T_opaque_cbox_ptr(bcx_ccx(bcx))))
 }
 
+fn trans_method_callee(bcx: @block_ctxt, callee_id: ast::node_id,
+                       self: @ast::expr, origin: typeck::method_origin)
+    -> lval_maybe_callee {
+    alt origin {
+      typeck::method_static(did) {
+        trans_static_callee(bcx, callee_id, self, did)
+      }
+      typeck::method_param(iid, off, p, b) {
+        trans_param_callee(bcx, callee_id, self, iid, off, p, b)
+      }
+      typeck::method_iface(off) {
+        trans_iface_callee(bcx, callee_id, self, off)
+      }
+    }
+}
+
 // Method callee where the method is statically known
-fn trans_static_callee(bcx: @block_ctxt, e: @ast::expr, base: @ast::expr,
-                       did: ast::def_id) -> lval_maybe_callee {
+fn trans_static_callee(bcx: @block_ctxt, callee_id: ast::node_id,
+                       base: @ast::expr, did: ast::def_id)
+    -> lval_maybe_callee {
     let {bcx, val} = trans_self_arg(bcx, base);
-    {env: self_env(val) with lval_static_fn(bcx, did, e.id)}
+    {env: self_env(val) with lval_static_fn(bcx, did, callee_id)}
 }
 
 fn wrapper_fn_ty(ccx: @crate_ctxt, dict_ty: TypeRef, m: ty::method)
@@ -79,7 +96,7 @@ fn wrapper_fn_ty(ccx: @crate_ctxt, dict_ty: TypeRef, m: ty::method)
 }
 
 fn trans_vtable_callee(bcx: @block_ctxt, self: ValueRef, dict: ValueRef,
-                       fld_expr: @ast::expr, iface_id: ast::def_id,
+                       callee_id: ast::node_id, iface_id: ast::def_id,
                        n_method: uint) -> lval_maybe_callee {
     let bcx = bcx, ccx = bcx_ccx(bcx), tcx = ccx.tcx;
     let method = ty::iface_methods(tcx, iface_id)[n_method];
@@ -90,7 +107,7 @@ fn trans_vtable_callee(bcx: @block_ctxt, self: ValueRef, dict: ValueRef,
     let generic = none;
     if vec::len(*method.tps) > 0u || ty::type_contains_params(tcx, fty) {
         let tydescs = [], tis = [];
-        let tptys = ty::node_id_to_type_params(tcx, fld_expr.id);
+        let tptys = ty::node_id_to_type_params(tcx, callee_id);
         for t in vec::tail_n(tptys, vec::len(tptys) - vec::len(*method.tps)) {
             let ti = none;
             let td = get_tydesc(bcx, t, true, ti).result;
@@ -102,24 +119,24 @@ fn trans_vtable_callee(bcx: @block_ctxt, self: ValueRef, dict: ValueRef,
                         static_tis: tis,
                         tydescs: tydescs,
                         param_bounds: method.tps,
-                        origins: bcx_ccx(bcx).dict_map.find(fld_expr.id)});
+                        origins: bcx_ccx(bcx).dict_map.find(callee_id)});
     }
     {bcx: bcx, val: mptr, kind: owned,
      env: dict_env(dict, self),
      generic: generic}
 }
 
 // Method callee where the dict comes from a type param
-fn trans_param_callee(bcx: @block_ctxt, fld_expr: @ast::expr,
+fn trans_param_callee(bcx: @block_ctxt, callee_id: ast::node_id,
                       base: @ast::expr, iface_id: ast::def_id, n_method: uint,
                       n_param: uint, n_bound: uint) -> lval_maybe_callee {
     let {bcx, val} = trans_self_arg(bcx, base);
     let dict = option::get(bcx.fcx.lltyparams[n_param].dicts)[n_bound];
-    trans_vtable_callee(bcx, val, dict, fld_expr, iface_id, n_method)
+    trans_vtable_callee(bcx, val, dict, callee_id, iface_id, n_method)
 }
 
 // Method callee where the dict comes from a boxed iface
-fn trans_iface_callee(bcx: @block_ctxt, fld_expr: @ast::expr,
+fn trans_iface_callee(bcx: @block_ctxt, callee_id: ast::node_id,
                       base: @ast::expr, n_method: uint)
     -> lval_maybe_callee {
     let tcx = bcx_tcx(bcx);
@@ -133,7 +150,7 @@ fn trans_iface_callee(bcx: @block_ctxt, fld_expr: @ast::expr,
     let iface_id = alt ty::struct(tcx, ty::expr_ty(tcx, base)) {
         ty::ty_iface(did, _) { did }
     };
-    trans_vtable_callee(bcx, self, dict, fld_expr, iface_id, n_method)
+    trans_vtable_callee(bcx, self, dict, callee_id, iface_id, n_method)
 }
 
 fn llfn_arg_tys(ft: TypeRef) -> {inputs: [TypeRef], output: TypeRef} {