librustc: Allow &T to be assigned to *T

src/libcore/rt.rs

@@ -34,9 +34,12 @@ extern mod rustrt {
 // 'rt_', otherwise the compiler won't find it. To fix this, see
 // gather_rust_rtcalls.
 #[rt(fail_)]
-pub fn rt_fail_(expr: *c_char, file: *c_char, line: size_t) {
-    cleanup_stack_for_failure();
-    rustrt::rust_upcall_fail(expr, file, line);
+pub fn rt_fail_(expr: *c_char, file: *c_char, line: size_t) -> ! {
+    unsafe {
+        cleanup_stack_for_failure();
+        rustrt::rust_upcall_fail(expr, file, line);
+        cast::transmute(())
+    }
 }
 
 #[rt(fail_bounds_check)]

src/librustc/front/config.rs

@@ -75,6 +75,7 @@ fn fold_foreign_mod(cx: ctxt, nm: ast::foreign_mod,
                                               |a| filter_view_item(cx, *a));
     return {
         sort: nm.sort,
+        abi: nm.abi,
         view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(*x)),
         items: filtered_items
     };

src/librustc/middle/borrowck.rs

@@ -513,6 +513,16 @@ impl borrowck_ctxt {
         cat_expr(self.tcx, self.method_map, expr)
     }
 
+    fn cat_expr_unadjusted(expr: @ast::expr) -> cmt {
+        cat_expr_unadjusted(self.tcx, self.method_map, expr)
+    }
+
+    fn cat_expr_autoderefd(expr: @ast::expr,
+                           adj: @ty::AutoAdjustment)
+                        -> cmt {
+        cat_expr_autoderefd(self.tcx, self.method_map, expr, adj)
+    }
+
     fn cat_def(id: ast::node_id,
                span: span,
                ty: ty::t,

src/librustc/middle/borrowck/check_loans.rs

@@ -362,7 +362,12 @@ impl check_loan_ctxt {
     }
 
     fn check_assignment(at: assignment_type, ex: @ast::expr) {
-        let cmt = self.bccx.cat_expr(ex);
+        // We don't use cat_expr() here because we don't want to treat
+        // auto-ref'd parameters in overloaded operators as rvalues.
+        let cmt = match self.bccx.tcx.adjustments.find(ex.id) {
+            None => self.bccx.cat_expr_unadjusted(ex),
+            Some(adj) => self.bccx.cat_expr_autoderefd(ex, adj)
+        };
 
         debug!("check_assignment(cmt=%s)",
                self.bccx.cmt_to_repr(cmt));

src/librustc/middle/mem_categorization.rs

@@ -573,6 +573,29 @@ fn cat_expr(
     return mcx.cat_expr(expr);
 }
 
+fn cat_expr_unadjusted(
+    tcx: ty::ctxt,
+    method_map: typeck::method_map,
+    expr: @ast::expr) -> cmt {
+
+    let mcx = &mem_categorization_ctxt {
+        tcx: tcx, method_map: method_map
+    };
+    return mcx.cat_expr_unadjusted(expr);
+}
+
+fn cat_expr_autoderefd(
+    tcx: ty::ctxt,
+    method_map: typeck::method_map,
+    expr: @ast::expr,
+    adj: @ty::AutoAdjustment) -> cmt {
+
+    let mcx = &mem_categorization_ctxt {
+        tcx: tcx, method_map: method_map
+    };
+    return mcx.cat_expr_autoderefd(expr, adj);
+}
+
 fn cat_def(
     tcx: ty::ctxt,
     method_map: typeck::method_map,

src/librustc/middle/trans/expr.rs

@@ -1572,7 +1572,7 @@ fn trans_assign_op(bcx: block,
     debug!("trans_assign_op(expr=%s)", bcx.expr_to_str(expr));
 
     // Evaluate LHS (destination), which should be an lvalue
-    let dst_datum = unpack_datum!(bcx, trans_lvalue(bcx, dst));
+    let dst_datum = unpack_datum!(bcx, trans_lvalue_unadjusted(bcx, dst));
 
     // A user-defined operator method
     if bcx.ccx().maps.method_map.find(expr.id).is_some() {

src/librustc/middle/typeck/infer/assignment.rs

@@ -136,9 +136,9 @@ priv impl Assign {
 
         match (a_bnd, b_bnd) {
             (Some(a_bnd), Some(b_bnd)) => {
-                // check for a case where a non-region pointer (@, ~) is
-                // being assigned to a region pointer:
                 match (ty::get(a_bnd).sty, ty::get(b_bnd).sty) {
+                    // check for a case where a non-region pointer (@, ~) is
+                    // being assigned to a region pointer:
                     (ty::ty_box(_), ty::ty_rptr(r_b, mt_b)) => {
                         let nr_b = ty::mk_box(self.infcx.tcx,
                                               {ty: mt_b.ty, mutbl: m_const});
@@ -184,8 +184,16 @@ priv impl Assign {
                                         a, nr_b, m_imm, b_f.meta.region)
                     }
 
+                    // check for &T being assigned to *T:
+                    (ty::ty_rptr(_, ref a_t), ty::ty_ptr(ref b_t)) => {
+                        match Sub(*self).mts(*a_t, *b_t) {
+                            Ok(_) => Ok(None),
+                            Err(e) => Err(e)
+                        }
+                    }
+
+                    // otherwise, assignment follows normal subtype rules:
                     _ => {
-                        // otherwise, assignment follows normal subtype rules:
                         to_ares(Sub(*self).tys(a, b))
                     }
                 }

src/libsyntax/ast.rs

@@ -1861,6 +1861,7 @@ impl foreign_abi : cmp::Eq {
 #[auto_deserialize]
 type foreign_mod =
     {sort: foreign_mod_sort,
+     abi: ident,
      view_items: ~[@view_item],
      items: ~[@foreign_item]};
 

src/libsyntax/ext/expand.rs

@@ -248,6 +248,26 @@ fn core_macros() -> ~str {
     #macro[[#warn[f, ...], log(core::warn, #fmt[f, ...])]];
     #macro[[#info[f, ...], log(core::info, #fmt[f, ...])]];
     #macro[[#debug[f, ...], log(core::debug, #fmt[f, ...])]];
+
+    macro_rules! die(
+        ($msg: expr) => (
+            {
+                do core::str::as_buf($msg) |msg_buf, _msg_len| {
+                    do core::str::as_buf(file!()) |file_buf, _file_len| {
+                        unsafe {
+                            let msg_buf = core::cast::transmute(msg_buf);
+                            let file_buf = core::cast::transmute(file_buf);
+                            let line = line!() as core::libc::size_t;
+                            core::rt::rt_fail_(msg_buf, file_buf, line)
+                        }
+                    }
+                }
+            }
+        );
+        () => (
+            die!(\"explicit failure\")
+        )
+    )
 }";
 }
 

src/libsyntax/fold.rs

@@ -546,8 +546,9 @@ fn noop_fold_mod(m: _mod, fld: ast_fold) -> _mod {
 
 fn noop_fold_foreign_mod(nm: foreign_mod, fld: ast_fold) -> foreign_mod {
     return {sort: nm.sort,
-         view_items: vec::map(nm.view_items, |x| fld.fold_view_item(*x)),
-         items: vec::map(nm.items, |x| fld.fold_foreign_item(*x))}
+            abi: nm.abi,
+            view_items: vec::map(nm.view_items, |x| fld.fold_view_item(*x)),
+            items: vec::map(nm.items, |x| fld.fold_foreign_item(*x))}
 }
 
 fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {

src/libsyntax/parse/parser.rs

@@ -3043,8 +3043,9 @@ impl Parser {
     }
 
     fn parse_foreign_mod_items(sort: ast::foreign_mod_sort,
-                               +first_item_attrs: ~[attribute]) ->
-        foreign_mod {
+                               +abi: ast::ident,
+                               +first_item_attrs: ~[attribute])
+                            -> foreign_mod {
         // Shouldn't be any view items since we've already parsed an item attr
         let {attrs_remaining, view_items, items: _, foreign_items} =
             self.parse_items_and_view_items(first_item_attrs,
@@ -3058,8 +3059,12 @@ impl Parser {
             initial_attrs = ~[];
             items.push(self.parse_foreign_item(attrs));
         }
-        return {sort: sort, view_items: view_items,
-            items: items};
+        return {
+            sort: sort,
+            abi: move abi,
+            view_items: view_items,
+            items: items
+        };
     }
 
     fn parse_item_foreign_mod(lo: BytePos,
@@ -3068,6 +3073,18 @@ impl Parser {
                               items_allowed: bool)
                            -> item_or_view_item {
 
+        // Parse the ABI.
+        let abi_opt;
+        match self.token {
+            token::LIT_STR(copy found_abi) => {
+                self.bump();
+                abi_opt = Some(found_abi);
+            }
+            _ => {
+                abi_opt = None;
+            }
+        }
+
         let mut must_be_named_mod = false;
         if self.is_keyword(~"mod") {
             must_be_named_mod = true;
@@ -3096,16 +3113,33 @@ impl Parser {
 
         // extern mod { ... }
         if items_allowed && self.eat(token::LBRACE) {
+            let abi;
+            match move abi_opt {
+                Some(move found_abi) => abi = move found_abi,
+                None => abi = special_idents::c_abi,
+            }
+
             let extra_attrs = self.parse_inner_attrs_and_next();
-            let m = self.parse_foreign_mod_items(sort, extra_attrs.next);
+            let m = self.parse_foreign_mod_items(sort,
+                                                 move abi,
+                                                 extra_attrs.next);
             self.expect(token::RBRACE);
+
             return iovi_item(self.mk_item(lo, self.last_span.hi, ident,
                                           item_foreign_mod(m), visibility,
                                           maybe_append(attrs,
                                                        Some(extra_attrs.
                                                             inner))));
         }
 
+        match abi_opt {
+            None => {}  // OK.
+            Some(_) => {
+                self.span_err(copy self.span, ~"an ABI may not be specified \
+                                                here");
+            }
+        }
+
         // extern mod foo;
         let metadata = self.parse_optional_meta();
         self.expect(token::SEMI);

src/libsyntax/parse/token.rs

@@ -322,6 +322,7 @@ mod special_idents {
     const intrinsic : ident = ident { repr: 32u };
     const clownshoes_foreign_mod: ident = ident { repr: 33 };
     const unnamed_field: ident = ident { repr: 34 };
+    const c_abi: ident = ident { repr: 35 };
 }
 
 struct ident_interner {
@@ -368,7 +369,8 @@ fn mk_ident_interner() -> @ident_interner {
                     @~"str", @~"TyVisitor", @~"arg", @~"descrim",
                     @~"__rust_abi", @~"__rust_stack_shim", @~"TyDesc",
                     @~"dtor", @~"main", @~"<opaque>", @~"blk", @~"static",
-                    @~"intrinsic", @~"__foreign_mod__"
+                    @~"intrinsic", @~"__foreign_mod__", @~"__field__",
+                    @~"C"
                 ];
 
                 let rv = @ident_interner {

src/libsyntax/print/pprust.rs

@@ -485,6 +485,7 @@ fn print_item(s: ps, &&item: @ast::item) {
       }
       ast::item_foreign_mod(nmod) => {
         head(s, visibility_qualified(item.vis, ~"extern"));
+        print_string(s, *s.intr.get(nmod.abi));
         match nmod.sort {
             ast::named => {
                 word_nbsp(s, ~"mod");

src/test/run-pass/extern-mod-abi.rs

@@ -0,0 +1,6 @@
+extern "C" {
+    fn pow(x: f64, y: f64) -> f64;
+}
+
+fn main() {}
+

src/test/run-pass/operator-overloading-explicit-self.rs

@@ -0,0 +1,16 @@
+struct S {
+    x: int
+}
+
+impl S {
+    pure fn add(&self, other: &S) -> S {
+        S { x: self.x + other.x }
+    }
+}
+
+fn main() {
+    let mut s = S { x: 1 };
+    s += S { x: 2 };
+    assert s.x == 3;
+}
+

src/test/run-pass/unsafe-pointer-assignability.rs

@@ -0,0 +1,12 @@
+fn f(x: *int) {
+    unsafe {
+        assert *x == 3;
+    }
+}
+
+fn main() {
+    f(&3);
+}
+
+
+