---

yaml
---
r: 138939
b: refs/heads/try2
c: b5334c3
h: refs/heads/master
i:
  138937: 93524c9
  138935: da0d66a
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: e28d4b3516f0703ddb5407bf8cd7fc7e273743bb
+refs/heads/try2: b5334c3095a024f934a91ba82bd88fe2696919d1
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/RELEASES.txt

@@ -1,8 +1,85 @@
-Version 0.6 (?)
+Version 0.6 (March 2013)
 ---------------------------
 
+   * ~??? changes, numerous bugfixes
+
+   * TODO:
+      * Ord/Cmp
+      * Lifetime changes
+      * Implicit self
+      * Remove `static` keyword
+      * Static method syntax
+      * `as Trait`
+      * `copy` removed?
+
+   * Syntax changes
+      * The self type parameter in traits is now spelled `Self`
+      * Replaced the `Durable` trait with the `'static` lifetime
+      * The old closure type syntax with the trailing sigil has been
+        removed in favor of the more consistent leading sigil
+      * `super` is a keyword, and may be prefixed to paths
+      * Trait bounds are separated with `+` instead of whitespace
+      * Traits are implemented with `impl Trait for Type`
+        instead of `impl Type: Trait`
+      * The `export` keyword has finally been removed
+      * The `move` keyword has been removed (linear types move by default)
+      * The interior mutability qualifier on vectors, `[mut T]`, has been
+        removed. Use `&mut [T]`, etc.
+      * `mut` is no longer valid in `~mut T`. Use inherited mutability
+      * `fail` is no longer a keyword. Use `fail!()`
+      * `assert` is no longer a keyword. Use `assert!()`
+      * `log` is no longer a keyword. use `debug!`, etc.
+      * 1-tuples may be represented as `(T,)`
+      * Struct fields may no longer be `mut`. Use inherited mutability,
+        `@mut T`, `core::mut` or `core::cell`
+      * `extern mod { ... }` is no longer valid syntax for foreign
+        function modules. Use extern blocks: `extern { ... }`
+      * Newtype enums removed. Used tuple-structs.
+      * Trait implementations no longer support visibility modifiers
+
+   * Semantic changes
+      * Linear types move by default, eliminating the `move` keyword
+      * All foreign functions are considered unsafe
+      * &mut is now unaliasable
+      * Writes to borrowed @mut pointers are prevented dynamically
+      * () has size 0
+      * The name of the main function can be customized using #[main]
+      * The default type of an inferred closure is &fn instead of @fn
+      * Name resolution continues to be tweaked
+      * Method visibility is inherited from the implementation declaration
+
+   * Other language changes
+      * Structural records have been removed
+      * Many more types can be used in constants, including enums
+        `static lifetime pointers and vectors
+      * Pattern matching over vectors improved and expanded
+      * Typechecking of closure types has been overhauled to
+        improve inference and eliminate unsoundness
+
    * Libraries
-     * `core::send_map` renamed to `core::hashmap`
+      * Lots of effort to organize the container API's around `core::container`
+      * `core::send_map` renamed to `core::hashmap`
+      * Added big integers to `std::bigint`
+      * Removed `core::oldcomm` module
+      * Added pipe-based `core::comm` module
+      * Reimplemented `std::treemap`
+      * Numeric traits have been reorganized under `core::num`
+      * `core::dvec` removed. Use `@mut ~[T]` or other language types
+      * `vec::slice` finally returns a slice
+      * `debug!` and friends don't require a format string, e.g. `debug!(Foo)`
+
+   * Tools
+      * Replaced the 'cargo' package manager with 'rustpkg'
+      * Added all-purpose 'rust' tool
+      * `rustc --test` now supports a benchmarks with the `#[bench]` attribute
+      * rustc now attempts to offer spelling suggestions
+
+   * Misc
+      * Improved support for ARM and Android
+      * Preliminary MIPS backend
+      * Improved foreign function ABI implementation for x86, x86_64
+      * Various and memory usage improvements
+      * Rust code may be embedded in foreign code under limited circumstances
 
 Version 0.5 (December 2012)
 ---------------------------

branches/try2/src/libcore/option.rs

@@ -42,6 +42,7 @@ let unwrapped_msg = match msg {
 */
 
 use cmp::{Eq,Ord};
+use ops::Add;
 use kinds::Copy;
 use util;
 use num::Zero;
@@ -85,6 +86,18 @@ impl<T:Ord> Ord for Option<T> {
     }
 }
 
+impl<T: Copy + Add<T,T>> Add<Option<T>, Option<T>> for Option<T> {
+    #[inline(always)]
+    pure fn add(&self, other: &Option<T>) -> Option<T> {
+        match (*self, *other) {
+            (None, None) => None,
+            (_, None) => *self,
+            (None, _) => *other,
+            (Some(ref lhs), Some(ref rhs)) => Some(*lhs + *rhs)
+        }
+    }
+}
+
 #[inline(always)]
 pub pure fn get<T:Copy>(opt: Option<T>) -> T {
     /*!

branches/try2/src/librustc/middle/check_const.rs

@@ -91,8 +91,8 @@ pub fn check_expr(sess: Session,
                   v: visit::vt<bool>) {
     if is_const {
         match e.node {
-          expr_unary(box(_), _) | expr_unary(uniq(_), _) |
-          expr_unary(deref, _) => {
+          expr_unary(deref, _) => { }
+          expr_unary(box(_), _) | expr_unary(uniq(_), _) => {
             sess.span_err(e.span,
                           ~"disallowed operator in constant expression");
             return;

branches/try2/src/librustc/middle/trans/consts.rs

@@ -10,6 +10,7 @@
 
 use core::prelude::*;
 
+use back::abi;
 use lib::llvm::{llvm, ValueRef, TypeRef, Bool, True, False};
 use metadata::csearch;
 use middle::const_eval;
@@ -94,30 +95,56 @@ pub fn const_vec(cx: @CrateContext, e: @ast::expr, es: &[@ast::expr])
     }
 }
 
-pub fn const_deref(cx: @CrateContext, v: ValueRef) -> ValueRef {
+fn const_addr_of(cx: @CrateContext, cv: ValueRef) -> ValueRef {
     unsafe {
-        let v = match cx.const_globals.find(&(v as int)) {
-            Some(v) => v,
-            None => v
+        let gv = do str::as_c_str("const") |name| {
+            llvm::LLVMAddGlobal(cx.llmod, val_ty(cv), name)
         };
+        llvm::LLVMSetInitializer(gv, cv);
+        llvm::LLVMSetGlobalConstant(gv, True);
+        gv
+    }
+}
+
+fn const_deref_ptr(cx: @CrateContext, v: ValueRef) -> ValueRef {
+    let v = match cx.const_globals.find(&(v as int)) {
+        Some(v) => v,
+        None => v
+    };
+    unsafe {
         fail_unless!(llvm::LLVMIsGlobalConstant(v) == True);
-        let v = llvm::LLVMGetInitializer(v);
-        v
+        llvm::LLVMGetInitializer(v)
     }
 }
 
-pub fn const_autoderef(cx: @CrateContext, ty: ty::t, v: ValueRef)
-    -> (ty::t, ValueRef) {
-    let mut t1 = ty;
-    let mut v1 = v;
-    loop {
-        // Only rptrs can be autoderef'ed in a const context.
-        match ty::get(t1).sty {
-            ty::ty_rptr(_, mt) => {
-                t1 = mt.ty;
-                v1 = const_deref(cx, v1);
-            }
-            _ => return (t1,v1)
+fn const_deref_newtype(cx: @CrateContext, v: ValueRef, t: ty::t)
+    -> ValueRef {
+    let repr = adt::represent_type(cx, t);
+    adt::const_get_field(cx, repr, v, 0, 0)
+}
+
+fn const_deref(cx: @CrateContext, v: ValueRef, t: ty::t, explicit: bool)
+    -> (ValueRef, ty::t) {
+    match ty::deref(cx.tcx, t, explicit) {
+        Some(ref mt) => {
+            fail_unless!(mt.mutbl != ast::m_mutbl);
+            let dv = match ty::get(t).sty {
+                ty::ty_ptr(*) | ty::ty_rptr(*) => {
+                     const_deref_ptr(cx, v)
+                }
+                ty::ty_enum(*) | ty::ty_struct(*) => {
+                    const_deref_newtype(cx, v, t)
+                }
+                _ => {
+                    cx.sess.bug(fmt!("Unexpected dereferenceable type %s",
+                                     ty_to_str(cx.tcx, t)))
+                }
+            };
+            (dv, mt.ty)
+        }
+        None => {
+            cx.sess.bug(fmt!("Can't dereference const of type %s",
+                             ty_to_str(cx.tcx, t)))
         }
     }
 }
@@ -142,15 +169,68 @@ pub fn get_const_val(cx: @CrateContext, def_id: ast::def_id) -> ValueRef {
 }
 
 pub fn const_expr(cx: @CrateContext, e: @ast::expr) -> ValueRef {
-    let ety = ty::expr_ty_adjusted(cx.tcx, e);
-    let llty = type_of::sizing_type_of(cx, ety);
-    let llconst = const_expr_unchecked(cx, e);
+    let mut llconst = const_expr_unadjusted(cx, e);
+    let ety = ty::expr_ty(cx.tcx, e);
+    match cx.tcx.adjustments.find(&e.id) {
+        None => { }
+        Some(@ty::AutoAddEnv(ty::re_static, ast::BorrowedSigil)) => {
+            llconst = C_struct(~[llconst, C_null(T_opaque_box_ptr(cx))])
+        }
+        Some(@ty::AutoAddEnv(ref r, ref s)) => {
+            cx.sess.span_bug(e.span, fmt!("unexpected const function: \
+                                           region %? sigil %?", *r, *s))
+        }
+        Some(@ty::AutoDerefRef(ref adj)) => {
+            let mut ty = ety;
+            let mut maybe_ptr = None;
+            for adj.autoderefs.times {
+                let (dv, dt) = const_deref(cx, llconst, ty, false);
+                maybe_ptr = Some(llconst);
+                llconst = dv;
+                ty = dt;
+            }
+
+            match adj.autoref {
+                None => { }
+                Some(ref autoref) => {
+                    fail_unless!(autoref.region == ty::re_static);
+                    fail_unless!(autoref.mutbl != ast::m_mutbl);
+                    // Don't copy data to do a deref+ref.
+                    let llptr = match maybe_ptr {
+                        Some(ptr) => ptr,
+                        None => const_addr_of(cx, llconst)
+                    };
+                    match autoref.kind {
+                        ty::AutoPtr => {
+                            llconst = llptr;
+                        }
+                        ty::AutoBorrowVec => {
+                            let size = machine::llsize_of(cx,
+                                                          val_ty(llconst));
+                            fail_unless!(abi::slice_elt_base == 0);
+                            fail_unless!(abi::slice_elt_len == 1);
+                            llconst = C_struct(~[llptr, size]);
+                        }
+                        _ => {
+                            cx.sess.span_bug(e.span,
+                                             fmt!("unimplemented const \
+                                                   autoref %?", autoref))
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let ety_adjusted = ty::expr_ty_adjusted(cx.tcx, e);
+    let llty = type_of::sizing_type_of(cx, ety_adjusted);
     let csize = machine::llsize_of_alloc(cx, val_ty(llconst));
     let tsize = machine::llsize_of_alloc(cx, llty);
     if csize != tsize {
         unsafe {
+            // XXX these values could use some context
             llvm::LLVMDumpValue(llconst);
-            llvm::LLVMDumpValue(C_null(llty));
+            llvm::LLVMDumpValue(C_undef(llty));
         }
         cx.sess.bug(fmt!("const %s of type %s has size %u instead of %u",
                          expr_repr(cx.tcx, e), ty_to_str(cx.tcx, ety),
@@ -159,7 +239,7 @@ pub fn const_expr(cx: @CrateContext, e: @ast::expr) -> ValueRef {
     llconst
 }
 
-fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
+fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
     unsafe {
         let _icx = cx.insn_ctxt("const_expr");
         return match /*bad*/copy e.node {
@@ -223,7 +303,10 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             return match u {
               ast::box(_)  |
               ast::uniq(_) |
-              ast::deref  => const_deref(cx, te),
+              ast::deref  => {
+                let (dv, _dt) = const_deref(cx, te, ty, true);
+                dv
+              }
               ast::not    => {
                 match ty::get(ty).sty {
                     ty::ty_bool => {
@@ -243,20 +326,18 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             }
           }
           ast::expr_field(base, field, _) => {
-              let bt = ty::expr_ty(cx.tcx, base);
+              let bt = ty::expr_ty_adjusted(cx.tcx, base);
               let brepr = adt::represent_type(cx, bt);
               let bv = const_expr(cx, base);
-              let (bt, bv) = const_autoderef(cx, bt, bv);
               do expr::with_field_tys(cx.tcx, bt, None) |discr, field_tys| {
                   let ix = ty::field_idx_strict(cx.tcx, field, field_tys);
                   adt::const_get_field(cx, brepr, bv, discr, ix)
               }
           }
 
           ast::expr_index(base, index) => {
-              let bt = ty::expr_ty(cx.tcx, base);
+              let bt = ty::expr_ty_adjusted(cx.tcx, base);
               let bv = const_expr(cx, base);
-              let (bt, bv) = const_autoderef(cx, bt, bv);
               let iv = match const_eval::eval_const_expr(cx.tcx, index) {
                   const_eval::const_int(i) => i as u64,
                   const_eval::const_uint(u) => u,
@@ -275,7 +356,7 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
                           let llunitty = type_of::type_of(cx, unit_ty);
                           let unit_sz = machine::llsize_of(cx, llunitty);
 
-                          (const_deref(cx, const_get_elt(cx, bv, [0])),
+                          (const_deref_ptr(cx, const_get_elt(cx, bv, [0])),
                            llvm::LLVMConstUDiv(const_get_elt(cx, bv, [1]),
                                                unit_sz))
                       },
@@ -355,13 +436,7 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             }
           }
           ast::expr_addr_of(ast::m_imm, sub) => {
-            let cv = const_expr(cx, sub);
-            let gv = do str::as_c_str("const") |name| {
-                llvm::LLVMAddGlobal(cx.llmod, val_ty(cv), name)
-            };
-            llvm::LLVMSetInitializer(gv, cv);
-            llvm::LLVMSetGlobalConstant(gv, True);
-            gv
+              const_addr_of(cx, const_expr(cx, sub))
           }
           ast::expr_tup(es) => {
               let ety = ty::expr_ty(cx.tcx, e);
@@ -420,26 +495,12 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             fail_unless!(pth.types.len() == 0);
             match cx.tcx.def_map.find(&e.id) {
                 Some(ast::def_fn(def_id, _purity)) => {
-                    let f = if !ast_util::is_local(def_id) {
+                    if !ast_util::is_local(def_id) {
                         let ty = csearch::get_type(cx.tcx, def_id).ty;
                         base::trans_external_path(cx, def_id, ty)
                     } else {
                         fail_unless!(ast_util::is_local(def_id));
                         base::get_item_val(cx, def_id.node)
-                    };
-                    let ety = ty::expr_ty_adjusted(cx.tcx, e);
-                    match ty::get(ety).sty {
-                        ty::ty_bare_fn(*) | ty::ty_ptr(*) => {
-                            llvm::LLVMConstPointerCast(f, T_ptr(T_i8()))
-                        }
-                        ty::ty_closure(*) => {
-                            C_struct(~[f, C_null(T_opaque_box_ptr(cx))])
-                        }
-                        _ => {
-                            cx.sess.span_bug(e.span, fmt!(
-                                "unexpected const fn type: %s",
-                                ty_to_str(cx.tcx, ety)))
-                        }
                     }
                 }
                 Some(ast::def_const(def_id)) => {