---

yaml
---
r: 36285
b: refs/heads/try2
c: 4589597
h: refs/heads/master
i:
  36283: 42ad20f
v: v3

Author: bstrie

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: f67bfe97389a256fc95216c29a2b8a066ee16a2c
+refs/heads/try2: 4589597785c4e485db82bc06c2c44ac2ebcced6a
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
 refs/heads/dist-snap: 22efa39382d41b084fde1719df7ae8ce5697d8c9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try2/AUTHORS.txt

@@ -26,6 +26,7 @@ Brian J. Burg <[email protected]>
 Brian Leibig <[email protected]>
 Chris Double <[email protected]>
 Chris Peterson <[email protected]>
+Chris Pressey <[email protected]>
 Damian Gryski <[email protected]>
 Damien Grassart <[email protected]>
 Daniel Brooks <[email protected]>

branches/try2/Makefile.in

@@ -341,6 +341,7 @@ HSREQ$(1)_H_$(3) = \
 	$$(HLIB$(1)_H_$(3))/$$(CFG_RUSTLLVM) \
 	$$(HCORELIB_DEFAULT$(1)_H_$(3)) \
 	$$(HSTDLIB_DEFAULT$(1)_H_$(3)) \
+	$$(HLIBSYNTAX_DEFAULT$(1)_H_$(3)) \
 	$$(HLIBRUSTC_DEFAULT$(1)_H_$(3)) \
 	$$(MKFILE_DEPS)
 
@@ -350,17 +351,31 @@ TSREQ$(1)_T_$(2)_H_$(3) = \
 	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_RUNTIME) \
 	$$(TLIB$(1)_T_$(2)_H_$(3))/libmorestack.a
 
-# Prerequisites for complete stageN targets
+# Prerequisites for a working stageN compiler and libraries
 SREQ$(1)_T_$(2)_H_$(3) = \
 	$$(TSREQ$(1)_T_$(2)_H_$(3)) \
 	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_CORELIB) \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB)
+
+# Prerequisites for a working stageN compiler and libraries
+CSREQ$(1)_T_$(2)_H_$(3) = \
+	$$(TSREQ$(1)_T_$(2)_H_$(3)) \
+	$$(HBIN$(1)_H_$(3))/fuzzer$$(X) \
+	$$(HBIN$(1)_H_$(3))/cargo$$(X) \
+	$$(HBIN$(1)_H_$(3))/rustdoc$$(X) \
+	$$(HBIN$(1)_H_$(3))/rusti$$(X) \
+	$$(HLIB$(1)_H_$(3))/$$(CFG_LIBFUZZER) \
+	$$(HLIB$(1)_H_$(3))/$$(CFG_LIBCARGO) \
+	$$(HLIB$(1)_H_$(3))/$$(CFG_LIBRUSTDOC) \
+	$$(HLIB$(1)_H_$(3))/$$(CFG_LIBRUSTI) \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_CORELIB) \
 	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB)  \
 	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBSYNTAX)  \
 	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTC) \
 	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBFUZZER) \
 	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBCARGO) \
 	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTDOC) \
-	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTI)  \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTI)
 
 ifeq ($(1),0)
 # Don't run the the stage0 compiler under valgrind - that ship has sailed
@@ -461,15 +476,7 @@ all: $(SREQ1$(CFG_HOST_TRIPLE)) $(GENERATED) docs
 
 else
 
-TSREQS :=											\
-	$(foreach target,$(CFG_TARGET_TRIPLES),			\
-		$(SREQ3_T_$(target)_H_$(CFG_HOST_TRIPLE)))
-FUZZ := $(HBIN2_H_$(CFG_HOST_TRIPLE))/fuzzer$(X)
-CARGO := $(HBIN2_H_$(CFG_HOST_TRIPLE))/cargo$(X)
-RUSTDOC := $(HBIN2_H_$(CFG_HOST_TRIPLE))/rustdoc$(X)
-RUSTI := $(HBIN2_H_$(CFG_HOST_TRIPLE))/rusti$(X)
-
-all: rustc $(GENERATED) docs $(FUZZ) $(CARGO) $(RUSTDOC) $(RUSTI)
+all: $(CSREQ3$(CFG_HOST_TRIPLE)) $(GENERATED) docs
 
 endif
 

branches/try2/configure

@@ -432,6 +432,15 @@ then
     fi
 fi
 
+# Force freebsd to build with clang; gcc doesn't like us there
+if [ $CFG_OSTYPE = unknown-freebsd ]
+then
+    step_msg "on FreeBSD, forcing use of clang"
+    CFG_ENABLE_CLANG=1
+    putvar CFG_ENABLE_CLANG
+fi
+
+
 if [ -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
 then
     err "either clang or gcc is required"

branches/try2/doc/tutorial.md

@@ -100,7 +100,7 @@ If you've fulfilled those prerequisites, something along these lines
 should work.
 
 ~~~~ {.notrust}
-$ wget http://dl.rust-lang.org/dist/rust-0.4.tar.gz
+$ curl -O http://dl.rust-lang.org/dist/rust-0.4.tar.gz
 $ tar -xzf rust-0.4.tar.gz
 $ cd rust-0.4
 $ ./configure
@@ -490,7 +490,7 @@ const MY_STRUCTY_PASSWORD: Password = Password { value: MY_PASSWORD };
 ## Operators
 
 Rust's set of operators contains very few surprises. Arithmetic is done with
-`*`, `/`, `%`, `+`, and `-` (multiply, divide, remainder, plus, minus). `-` is
+`*`, `/`, `%`, `+`, and `-` (multiply, divide, take remainder, add, subtract). `-` is
 also a unary prefix operator that negates numbers. As in C, the bit operators
 `>>`, `<<`, `&`, `|`, and `^` are also supported.
 
@@ -608,7 +608,7 @@ a wildcard pattern that matches any single value. The asterisk (`*`)
 is a different wildcard that can match one or more fields in an `enum`
 variant.
 
-The patterns in an match arm are followed by a fat arrow, `=>`, then an
+The patterns in a match arm are followed by a fat arrow, `=>`, then an
 expression to evaluate. Each case is separated by commas. It's often
 convenient to use a block expression for each case, in which case the
 commas are optional.
@@ -865,7 +865,7 @@ fn area(sh: Shape) -> float {
 }
 ~~~~
 
-You can write a lone `_` to ignore an individual fields, and can
+You can write a lone `_` to ignore an individual field, and can
 ignore all fields of a variant like: `Circle(*)`. As in their
 introduction form, nullary enum patterns are written without
 parentheses.
@@ -1096,7 +1096,7 @@ All pointer types can be dereferenced with the `*` unary operator.
 Managed boxes are pointers to heap-allocated, garbage collected
 memory.  Applying the unary `@` operator to an expression creates a
 managed box. The resulting box contains the result of the
-expression. Copying a shared box, as happens during assignment, only
+expression. Copying a managed box, as happens during assignment, only
 copies a pointer, never the contents of the box.
 
 ~~~~
@@ -1145,7 +1145,7 @@ Managed boxes never cross task boundaries.
 In contrast with managed boxes, owned boxes have a single owning
 memory slot and thus two owned boxes may not refer to the same
 memory. All owned boxes across all tasks are allocated on a single
-_exchange heap_, where their uniquely owned nature allows tasks to
+_exchange heap_, where their uniquely-owned nature allows tasks to
 exchange them efficiently.
 
 Because owned boxes are uniquely owned, copying them requires allocating
@@ -1158,7 +1158,7 @@ let x = ~10;
 let y = x; // error: copying a non-implicitly copyable type
 ~~~~
 
-If you really want to copy a unique box you must say so explicitly.
+If you really want to copy an owned box you must say so explicitly.
 
 ~~~~
 let x = ~10;
@@ -1190,7 +1190,7 @@ become the sole owner of the box.
 
 Rust borrowed pointers are a general purpose reference/pointer type,
 similar to the C++ reference type, but guaranteed to point to valid
-memory. In contrast with owned pointers, where the holder of a unique
+memory. In contrast with owned pointers, where the holder of an owned
 pointer is the owner of the pointed-to memory, borrowed pointers never
 imply ownership. Pointers may be borrowed from any type, in which case
 the pointer is guaranteed not to outlive the value it points to.
@@ -1210,14 +1210,14 @@ contains a point, but allocated in a different location:
 ~~~
 # struct Point { x: float, y: float }
 let on_the_stack : Point  =  Point {x: 3.0, y: 4.0};
-let shared_box   : @Point = @Point {x: 5.0, y: 1.0};
-let unique_box   : ~Point = ~Point {x: 7.0, y: 9.0};
+let managed_box  : @Point = @Point {x: 5.0, y: 1.0};
+let owned_box    : ~Point = ~Point {x: 7.0, y: 9.0};
 ~~~
 
 Suppose we wanted to write a procedure that computed the distance
 between any two points, no matter where they were stored. For example,
 we might like to compute the distance between `on_the_stack` and
-`shared_box`, or between `shared_box` and `unique_box`. One option is
+`managed_box`, or between `managed_box` and `owned_box`. One option is
 to define a function that takes two arguments of type point—that is,
 it takes the points by value. But this will cause the points to be
 copied when we call the function. For points, this is probably not so
@@ -1241,11 +1241,11 @@ Now we can call `compute_distance()` in various ways:
 ~~~
 # struct Point{ x: float, y: float };
 # let on_the_stack : Point  =  Point {x: 3.0, y: 4.0};
-# let shared_box   : @Point = @Point {x: 5.0, y: 1.0};
-# let unique_box   : ~Point = ~Point {x: 7.0, y: 9.0};
+# let managed_box  : @Point = @Point {x: 5.0, y: 1.0};
+# let owned_box    : ~Point = ~Point {x: 7.0, y: 9.0};
 # fn compute_distance(p1: &Point, p2: &Point) -> float { 0f }
-compute_distance(&on_the_stack, shared_box);
-compute_distance(shared_box, unique_box);
+compute_distance(&on_the_stack, managed_box);
+compute_distance(managed_box, owned_box);
 ~~~
 
 Here the `&` operator is used to take the address of the variable
@@ -1255,11 +1255,11 @@ value. We also call this _borrowing_ the local variable
 `on_the_stack`, because we are created an alias: that is, another
 route to the same data.
 
-In the case of the boxes `shared_box` and `unique_box`, however, no
+In the case of the boxes `managed_box` and `owned_box`, however, no
 explicit action is necessary. The compiler will automatically convert
 a box like `@point` or `~point` to a borrowed pointer like
 `&point`. This is another form of borrowing; in this case, the
-contents of the shared/unique box is being lent out.
+contents of the managed/owned box is being lent out.
 
 Whenever a value is borrowed, there are some limitations on what you
 can do with the original. For example, if the contents of a variable

branches/try2/mk/install.mk

@@ -33,7 +33,7 @@ PTR$(1)$(2) = $$(PREFIX_LIB)/rustc/$(1)
 PTB$(1)$(2) = $$(PTR$(1)$(2))/bin
 PTL$(1)$(2) = $$(PTR$(1)$(2))/$(CFG_LIBDIR)
 
-install-target-$(1)-host-$(2): $$(SREQ$$(ISTAGE)_T_$(1)_H_$(2))
+install-target-$(1)-host-$(2): $$(CSREQ$$(ISTAGE)_T_$(1)_H_$(2))
 	$$(Q)mkdir -p $$(PTL$(1)$(2))
 	$$(Q)$$(call INSTALL,$$(TL$(1)$(2)),$$(PTL$(1)$(2)),$$(CFG_RUNTIME))
 	$$(Q)$$(call INSTALL_LIB, \
@@ -74,7 +74,7 @@ PHB = $(PREFIX_BIN)
 # Shorthand for the prefix bin directory
 PHL = $(PREFIX_LIB)
 
-install-host: $(SREQ$(ISTAGE)_T_$(CFG_HOST_TRIPLE)_H_$(CFG_HOST_TRIPLE))
+install-host: $(CSREQ$(ISTAGE)_T_$(CFG_HOST_TRIPLE)_H_$(CFG_HOST_TRIPLE))
 	$(Q)mkdir -p $(PREFIX_BIN)
 	$(Q)mkdir -p $(PREFIX_LIB)
 	$(Q)mkdir -p $(PREFIX_ROOT)/share/man/man1

branches/try2/mk/tests.mk

@@ -352,7 +352,8 @@ $(3)/test/rustctest.stage$(1)-$(2)$$(X):					\
 		$$(COMPILER_CRATE)									\
 		$$(COMPILER_INPUTS)									\
 		$$(SREQ$(1)_T_$(2)_H_$(3))							\
-		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_RUSTLLVM)
+		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_RUSTLLVM) \
+                $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBSYNTAX)
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
 

branches/try2/src/libcore/result.rs

@@ -103,11 +103,11 @@ pub pure fn to_either<T: Copy, U: Copy>(res: &Result<U, T>)
  *         ok(parse_bytes(buf))
  *     }
  */
-pub fn chain<T, U: Copy, V: Copy>(res: Result<T, V>, op: fn(t: T)
+pub fn chain<T, U, V>(res: Result<T, V>, op: fn(t: T)
     -> Result<U, V>) -> Result<U, V> {
     match move res {
         Ok(move t) => op(move t),
-        Err(move e) => Err(e)
+        Err(move e) => Err(move e)
     }
 }
 
@@ -119,13 +119,13 @@ pub fn chain<T, U: Copy, V: Copy>(res: Result<T, V>, op: fn(t: T)
  * immediately returned.  This function can be used to pass through a
  * successful result while handling an error.
  */
-pub fn chain_err<T: Copy, U: Copy, V: Copy>(
+pub fn chain_err<T, U, V>(
     res: Result<T, V>,
     op: fn(t: V) -> Result<T, U>)
     -> Result<T, U> {
     match move res {
-      Ok(move t) => Ok(t),
-      Err(move v) => op(v)
+      Ok(move t) => Ok(move t),
+      Err(move v) => op(move v)
     }
 }
 

branches/try2/src/libfuzzer/fuzzer.rs

@@ -225,7 +225,7 @@ fn as_str(f: fn@(+x: io::Writer)) -> ~str {
     io::with_str_writer(f)
 }
 
-fn check_variants_of_ast(crate: ast::crate, codemap: @codemap::CodeMap,
+fn check_variants_of_ast(crate: ast::crate, codemap: codemap::CodeMap,
                          filename: &Path, cx: context) {
     let stolen = steal(crate, cx.mode);
     let extra_exprs = vec::filter(common_exprs(),
@@ -239,7 +239,7 @@ fn check_variants_of_ast(crate: ast::crate, codemap: @codemap::CodeMap,
 
 fn check_variants_T<T: Copy>(
   crate: ast::crate,
-  codemap: @codemap::CodeMap,
+  codemap: codemap::CodeMap,
   filename: &Path,
   thing_label: ~str,
   things: ~[T],

branches/try2/src/librustc/driver/driver.rs

@@ -354,7 +354,7 @@ fn pretty_print_input(sess: Session, cfg: ast::crate_cfg, input: input,
       ppm_expanded | ppm_normal => pprust::no_ann()
     };
     let is_expanded = upto != cu_parse;
-    let src = sess.codemap.get_filemap(source_name(input)).src;
+    let src = codemap::get_filemap(sess.codemap, source_name(input)).src;
     do io::with_str_reader(*src) |rdr| {
         pprust::print_crate(sess.codemap, sess.parse_sess.interner,
                             sess.span_diagnostic, crate,
@@ -574,7 +574,7 @@ fn build_session_options(binary: ~str,
 
 fn build_session(sopts: @session::options,
                  demitter: diagnostic::emitter) -> Session {
-    let codemap = @codemap::CodeMap::new();
+    let codemap = codemap::new_codemap();
     let diagnostic_handler =
         diagnostic::mk_handler(Some(demitter));
     let span_diagnostic_handler =
@@ -583,7 +583,7 @@ fn build_session(sopts: @session::options,
 }
 
 fn build_session_(sopts: @session::options,
-                  cm: @codemap::CodeMap,
+                  cm: codemap::CodeMap,
                   demitter: diagnostic::emitter,
                   span_diagnostic_handler: diagnostic::span_handler)
                -> Session {

branches/try2/src/librustc/driver/session.rs

@@ -131,7 +131,7 @@ type Session_ = {targ_cfg: @config,
                  opts: @options,
                  cstore: metadata::cstore::CStore,
                  parse_sess: parse_sess,
-                 codemap: @codemap::CodeMap,
+                 codemap: codemap::CodeMap,
                  // For a library crate, this is always none
                  mut main_fn: Option<(node_id, codemap::span)>,
                  span_diagnostic: diagnostic::span_handler,

branches/try2/src/librustc/front/config.rs

@@ -83,9 +83,9 @@ fn fold_foreign_mod(cx: ctxt, nm: ast::foreign_mod,
 fn fold_item_underscore(cx: ctxt, item: ast::item_,
                         fld: fold::ast_fold) -> ast::item_ {
     let item = match item {
-        ast::item_impl(a, b, c, Some(methods)) => {
+        ast::item_impl(a, b, c, methods) => {
             let methods = methods.filter(|m| method_in_cfg(cx, *m) );
-            ast::item_impl(a, b, c, Some(methods))
+            ast::item_impl(a, b, c, methods)
         }
         ast::item_trait(a, b, ref methods) => {
             let methods = methods.filter(|m| trait_method_in_cfg(cx, m) );

branches/try2/src/librustc/front/core_inject.rs

@@ -32,14 +32,14 @@ fn inject_libcore_ref(sess: Session,
 
     let vi1 = @{node: ast::view_item_use(sess.ident_of(~"core"), ~[], n1),
                 attrs: ~[],
-                vis: ast::public,
+                vis: ast::private,
                 span: dummy_sp()};
     let vp = spanned(ast::view_path_glob(
         ident_to_path(dummy_sp(), sess.ident_of(~"core")),
         n2));
     let vi2 = @{node: ast::view_item_import(~[vp]),
                 attrs: ~[],
-                vis: ast::public,
+                vis: ast::private,
                 span: dummy_sp()};
 
     let vis = vec::append(~[vi1, vi2], crate.node.module.view_items);

branches/try2/src/librustc/front/intrinsic.rs

@@ -1,4 +1,4 @@
-// NB: this file is #include_str'ed into the compiler, re-parsed
+// NB: this file is include_str!'ed into the compiler, re-parsed
 // and injected into each crate the compiler builds. Keep it small.
 
 mod intrinsic {

branches/try2/src/librustc/front/test.rs

@@ -29,7 +29,13 @@ type test_ctxt =
 fn modify_for_testing(sess: session::Session,
                       crate: @ast::crate) -> @ast::crate {
 
-    if sess.opts.test {
+    // We generate the test harness when building in the 'test'
+    // configuration, either with the '--test' or '--cfg test'
+    // command line options.
+    let should_test = attr::contains(crate.node.config,
+                                     attr::mk_word_item(~"test"));
+
+    if should_test {
         generate_test_harness(sess, crate)
     } else {
         strip_test_functions(crate)
@@ -65,14 +71,15 @@ fn strip_test_functions(crate: @ast::crate) -> @ast::crate {
 fn fold_mod(cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod {
 
     // Remove any defined main function from the AST so it doesn't clash with
-    // the one we're going to add.
+    // the one we're going to add. Only if compiling an executable.
 
     // FIXME (#2403): This is sloppy. Instead we should have some mechanism to
     // indicate to the translation pass which function we want to be main.
     fn nomain(cx: test_ctxt, item: @ast::item) -> Option<@ast::item> {
         match item.node {
           ast::item_fn(*) => {
-            if item.ident == cx.sess.ident_of(~"main") {
+            if item.ident == cx.sess.ident_of(~"main")
+                && !cx.sess.building_library {
                 option::None
             } else { option::Some(item) }
           }