---

yaml
---
r: 146751
b: refs/heads/try2
c: 020126e
h: refs/heads/master
i:
  146749: a127d31
  146747: 275d1ed
  146743: e5dcaa0
  146735: 739193a
  146719: e3dd88c
  146687: 06c094d
v: v3

Author: huonw

[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: 1dea21f41d28640d8fa6e9d43a55b9a034383f34
+refs/heads/try2: 020126ef75e318267415758cf771f25c3ac83bdd
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/configure

@@ -520,20 +520,14 @@ then
     fi
 fi
 
-BIN_SUF=
-if [ $CFG_OSTYPE = "pc-mingw32" ]
-then
-    BIN_SUF=.exe
-fi
-
 if [ ! -z "$CFG_ENABLE_LOCAL_RUST" ]
 then
-    if [ ! -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} ]
+    if [ ! -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc ]
     then
         err "no local rust to use"
     else
-        LRV=`${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} --version`
-        step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: $LRV"
+        LRV=`${CFG_LOCAL_RUST_ROOT}/bin/rustc --version`
+        step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: " $LRV
     fi
 fi
 

branches/try2/doc/rust.md

@@ -1131,8 +1131,9 @@ block.
 let fptr: extern "C" fn() -> ~[int] = new_vec;
 ~~~~
 
-Extern functions may be called directly from Rust code as Rust uses large,
-contiguous stack segments like C.
+Extern functions may be called from Rust code, but
+caution must be taken with respect to the size of the stack
+segment, just as when calling an extern function normally.
 
 ### Type definitions
 
@@ -3161,7 +3162,7 @@ Borrowed pointers (`&`)
     Borrowed pointers arise by (automatic) conversion from owning pointers, managed pointers,
     or by applying the borrowing operator `&` to some other value,
     including [lvalues, rvalues or temporaries](#lvalues-rvalues-and-temporaries).
-    Borrowed pointers are written `&content`, or in some cases `&'f content` for some lifetime-variable `f`,
+    Borrowed pointers are written `&content`, or in some cases `&f/content` for some lifetime-variable `f`,
     for example `&int` means a borrowed pointer to an integer.
     Copying a borrowed pointer is a "shallow" operation:
     it involves only copying the pointer itself.
@@ -3596,9 +3597,9 @@ and releases them back to its environment when they are no longer needed.
 The default implementation of the service-provider interface
 consists of the C runtime functions `malloc` and `free`.
 
-The runtime memory-management system, in turn, supplies Rust tasks with
-facilities for allocating releasing stacks, as well as allocating and freeing
-heap data.
+The runtime memory-management system, in turn, supplies Rust tasks
+with facilities for allocating, extending and releasing stacks,
+as well as allocating and freeing heap data.
 
 ### Built in types
 
@@ -3761,6 +3762,7 @@ have come and gone during the course of Rust's development:
 
 Additional specific influences can be seen from the following languages:
 
+* The stack-growth implementation of Go.
 * The structural algebraic types and compilation manager of SML.
 * The attribute and assembly systems of C#.
 * The references and deterministic destructor system of C++.

branches/try2/doc/tutorial.md

@@ -890,7 +890,9 @@ calling the destructor, and the owner determines whether the object is mutable.
 
 Ownership is recursive, so mutability is inherited recursively and a destructor
 destroys the contained tree of owned objects. Variables are top-level owners
-and destroy the contained object when they go out of scope.
+and destroy the contained object when they go out of scope. A box managed by
+the garbage collector starts a new ownership tree, and the destructor is called
+when it is collected.
 
 ~~~~
 // the struct owns the objects contained in the `x` and `y` fields
@@ -1007,6 +1009,51 @@ let mut s = r; // box becomes mutable
 let t = s; // box becomes immutable
 ~~~~
 
+# Managed boxes
+
+A managed box (`@`) is a heap allocation with the lifetime managed by a
+task-local garbage collector. It will be destroyed at some point after there
+are no references left to the box, no later than the end of the task. Managed
+boxes lack an owner, so they start a new ownership tree and don't inherit
+mutability. They do own the contained object, and mutability is defined by the
+type of the managed box (`@` or `@mut`). An object containing a managed box is
+not `Owned`, and can't be sent between tasks.
+
+~~~~
+let a = @5; // immutable
+
+let mut b = @5; // mutable variable, immutable box
+b = @10;
+
+let c = @mut 5; // immutable variable, mutable box
+*c = 10;
+
+let mut d = @mut 5; // mutable variable, mutable box
+*d += 5;
+d = @mut 15;
+~~~~
+
+A mutable variable and an immutable variable can refer to the same box, given
+that their types are compatible. Mutability of a box is a property of its type,
+however, so for example a mutable handle to an immutable box cannot be
+assigned a reference to a mutable box.
+
+~~~~
+let a = @1;     // immutable box
+let b = @mut 2; // mutable box
+
+let mut c : @int;       // declare a variable with type managed immutable int
+let mut d : @mut int;   // and one of type managed mutable int
+
+c = a;          // box type is the same, okay
+d = b;          // box type is the same, okay
+~~~~
+
+~~~~ {.xfail-test}
+// but b cannot be assigned to c, or a to d
+c = b;          // error
+~~~~
+
 # Borrowed pointers
 
 Rust's borrowed pointers are a general purpose reference type. In contrast with
@@ -1300,52 +1347,6 @@ defined in [`std::vec`] and [`std::str`].
 [`std::vec`]: std/vec/index.html
 [`std::str`]: std/str/index.html
 
-# Ownership escape hatches
-
-Ownership can cleanly describe tree-like data structures, and borrowed pointers provide non-owning
-references. However, more flexibility is often desired and Rust provides ways to escape from strict
-single parent ownership.
-
-The standard library provides the `std::rc::Rc` pointer type to express *shared ownership* over a
-reference counted box. As soon as all of the `Rc` pointers go out of scope, the box and the
-contained value are destroyed.
-
-~~~
-use std::rc::Rc;
-
-// A fixed-size array allocated in a reference-counted box
-let x = Rc::new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-let y = x.clone(); // a new owner
-let z = x; // this moves `x` into `z`, rather than creating a new owner
-
-assert_eq!(*z.borrow(), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-
-let mut a = Rc::new([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]); // the variable is mutable, but not the box
-a = z;
-~~~
-
-A garbage collected pointer is provided via `std::gc::Gc`, with a task-local garbage collector
-having ownership of the box. It allows the creation of cycles, and the individual `Gc` pointers do
-not have a destructor.
-
-~~~
-use std::gc::Gc;
-
-// A fixed-size array allocated in a garbage-collected box
-let x = Gc::new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-let y = x; // does not perform a move, unlike with `Rc`
-let z = x;
-
-assert_eq!(*z.borrow(), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-~~~
-
-With shared ownership, mutability cannot be inherited so the boxes are always immutable. However,
-it's possible to use *dynamic* mutability via types like `std::cell::Cell` where freezing is handled
-via dynamic checks and can fail at runtime.
-
-The `Rc` and `Gc` types are not sendable, so they cannot be used to share memory between tasks. Safe
-immutable and mutable shared memory is provided by the `extra::arc` module.
-
 # Closures
 
 Named functions, like those we've seen so far, may not refer to local

branches/try2/src/etc/local_stage0.sh

@@ -3,8 +3,8 @@
 TARG_DIR=$1
 PREFIX=$2
 
-LIB_DIR=lib
-LIB_PREFIX=lib
+BINDIR=bin
+LIBDIR=lib
 
 OS=`uname -s`
 case $OS in
@@ -21,8 +21,7 @@ case $OS in
     (*)
 	BIN_SUF=.exe
 	LIB_SUF=.dll
-	LIB_DIR=bin
-	LIB_PREFIX=
+	LIBDIR=bin
 	break
 	;;
 esac
@@ -32,7 +31,7 @@ if [ -z $PREFIX ]; then
     exit 1
 fi
 
-if [ ! -e ${PREFIX}/bin/rustc${BIN_SUF} ]; then
+if [ ! -e ${PREFIX}/bin/rustc ]; then
     echo "No local rust installed at ${PREFIX}"
     exit 1
 fi
@@ -42,9 +41,9 @@ if [ -z $TARG_DIR ]; then
     exit 1
 fi
 
-cp ${PREFIX}/bin/rustc${BIN_SUF} ${TARG_DIR}/stage0/bin/
-cp ${PREFIX}/${LIB_DIR}/rustc/${TARG_DIR}/${LIB_DIR}/* ${TARG_DIR}/stage0/${LIB_DIR}/
-cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}extra*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
-cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}rust*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
-cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}std*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
-cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}syntax*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
+cp ${PREFIX}/bin/rustc ${TARG_DIR}/stage0/bin/
+cp ${PREFIX}/lib/rustc/${TARG_DIR}/${LIBDIR}/* ${TARG_DIR}/stage0/${LIBDIR}/
+cp ${PREFIX}/lib/libextra*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/
+cp ${PREFIX}/lib/librust*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/
+cp ${PREFIX}/lib/libstd*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/
+cp ${PREFIX}/lib/libsyntax*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/

branches/try2/src/librustc/lib/llvm.rs

@@ -33,7 +33,6 @@ pub enum CallConv {
     ColdCallConv = 9,
     X86StdcallCallConv = 64,
     X86FastcallCallConv = 65,
-    X86_64_Win64 = 79,
 }
 
 pub enum Visibility {

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

@@ -75,7 +75,6 @@ pub enum lint {
     type_limits,
     type_overflow,
     unused_unsafe,
-    unsafe_block,
 
     managed_heap_memory,
     owned_heap_memory,
@@ -237,13 +236,6 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         default: warn
     }),
 
-    ("unsafe_block",
-     LintSpec {
-        lint: unsafe_block,
-        desc: "usage of an `unsafe` block",
-        default: allow
-    }),
-
     ("unused_variable",
      LintSpec {
         lint: unused_variable,
@@ -878,7 +870,8 @@ fn check_pat_non_uppercase_statics(cx: &Context, p: &ast::Pat) {
 
 fn check_unused_unsafe(cx: &Context, e: &ast::Expr) {
     match e.node {
-        // Don't warn about generated blocks, that'll just pollute the output.
+        // Don't warn about generated blocks, that'll just pollute the
+        // output.
         ast::ExprBlock(ref blk) => {
             if blk.rules == ast::UnsafeBlock(ast::UserProvided) &&
                 !cx.tcx.used_unsafe.contains(&blk.id) {
@@ -890,16 +883,6 @@ fn check_unused_unsafe(cx: &Context, e: &ast::Expr) {
     }
 }
 
-fn check_unsafe_block(cx: &Context, e: &ast::Expr) {
-    match e.node {
-        // Don't warn about generated blocks, that'll just pollute the output.
-        ast::ExprBlock(ref blk) if blk.rules == ast::UnsafeBlock(ast::UserProvided) => {
-            cx.span_lint(unsafe_block, blk.span, "usage of an `unsafe` block");
-        }
-        _ => ()
-    }
-}
-
 fn check_unused_mut_pat(cx: &Context, p: @ast::Pat) {
     match p.node {
         ast::PatIdent(ast::BindByValue(ast::MutMutable),
@@ -1143,7 +1126,6 @@ impl<'self> Visitor<()> for Context<'self> {
         check_while_true_expr(self, e);
         check_stability(self, e);
         check_unused_unsafe(self, e);
-        check_unsafe_block(self, e);
         check_unnecessary_allocation(self, e);
         check_heap_expr(self, e);
 

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

@@ -29,7 +29,7 @@ use syntax::parse::token;
 use syntax::parse::token::{ident_interner, interner_get};
 use syntax::parse::token::special_idents;
 use syntax::print::pprust::path_to_str;
-use syntax::codemap::{Span, dummy_sp, Pos};
+use syntax::codemap::{Span, dummy_sp, BytePos};
 use syntax::opt_vec::OptVec;
 use syntax::visit;
 use syntax::visit::Visitor;
@@ -2624,7 +2624,7 @@ impl Resolver {
                     if "???" == module_name {
                         let span = Span {
                             lo: span.lo,
-                            hi: span.lo + Pos::from_uint(segment_name.len()),
+                            hi: span.lo + BytePos(segment_name.len()),
                             expn_info: span.expn_info,
                         };
                         self.resolve_error(span,

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

@@ -33,7 +33,7 @@ use syntax::{ast};
 use syntax::{attr, ast_map};
 use syntax::parse::token::special_idents;
 use syntax::abi::{RustIntrinsic, Rust, Stdcall, Fastcall, System,
-                  Cdecl, Aapcs, C, AbiSet, Win64};
+                  Cdecl, Aapcs, C, AbiSet};
 use util::ppaux::{Repr, UserString};
 use middle::trans::type_::Type;
 
@@ -96,7 +96,6 @@ pub fn llvm_calling_convention(ccx: &mut CrateContext,
             Stdcall => lib::llvm::X86StdcallCallConv,
             Fastcall => lib::llvm::X86FastcallCallConv,
             C => lib::llvm::CCallConv,
-            Win64 => lib::llvm::X86_64_Win64,
 
             // NOTE These API constants ought to be more specific
             Cdecl => lib::llvm::CCallConv,
@@ -399,19 +398,11 @@ pub fn register_rust_fn_with_foreign_abi(ccx: @mut CrateContext,
 
     let tys = foreign_types_for_id(ccx, node_id);
     let llfn_ty = lltype_for_fn_from_foreign_types(&tys);
-    let t = ty::node_id_to_type(ccx.tcx, node_id);
-    let cconv = match ty::get(t).sty {
-        ty::ty_bare_fn(ref fn_ty) => {
-            let c = llvm_calling_convention(ccx, fn_ty.abis);
-            c.unwrap_or(lib::llvm::CCallConv)
-        }
-        _ => lib::llvm::CCallConv
-    };
     let llfn = base::register_fn_llvmty(ccx,
                                         sp,
                                         sym,
                                         node_id,
-                                        cconv,
+                                        lib::llvm::CCallConv,
                                         llfn_ty);
     add_argument_attributes(&tys, llfn);
     debug!("register_rust_fn_with_foreign_abi(node_id={:?}, llfn_ty={}, llfn={})",

branches/try2/src/librustc/middle/typeck/astconv.rs

@@ -560,6 +560,10 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:RegionScope>(
             ast_ty.span,
             "found `ty_infer` in unexpected place");
       }
+      ast::ty_mac(_) => {
+        tcx.sess.span_bug(ast_ty.span,
+                          "found `ty_mac` in unexpected place");
+      }
     };
 
     tcx.ast_ty_to_ty_cache.insert(ast_ty.id, ty::atttce_resolved(typ));

branches/try2/src/librustdoc/html/render.rs

@@ -466,15 +466,14 @@ impl DocFolder for Cache {
         // Register any generics to their corresponding string. This is used
         // when pretty-printing types
         match item.inner {
-            clean::StructItem(ref s)          => self.generics(&s.generics),
-            clean::EnumItem(ref e)            => self.generics(&e.generics),
-            clean::FunctionItem(ref f)        => self.generics(&f.generics),
-            clean::TypedefItem(ref t)         => self.generics(&t.generics),
-            clean::TraitItem(ref t)           => self.generics(&t.generics),
-            clean::ImplItem(ref i)            => self.generics(&i.generics),
-            clean::TyMethodItem(ref i)        => self.generics(&i.generics),
-            clean::MethodItem(ref i)          => self.generics(&i.generics),
-            clean::ForeignFunctionItem(ref f) => self.generics(&f.generics),
+            clean::StructItem(ref s)   => self.generics(&s.generics),
+            clean::EnumItem(ref e)     => self.generics(&e.generics),
+            clean::FunctionItem(ref f) => self.generics(&f.generics),
+            clean::TypedefItem(ref t)  => self.generics(&t.generics),
+            clean::TraitItem(ref t)    => self.generics(&t.generics),
+            clean::ImplItem(ref i)     => self.generics(&i.generics),
+            clean::TyMethodItem(ref i) => self.generics(&i.generics),
+            clean::MethodItem(ref i)   => self.generics(&i.generics),
             _ => {}
         }