---

yaml
---
r: 160703
b: refs/heads/master
c: 60299d7
h: refs/heads/master
i:
  160701: 69ec7e0
  160699: a50dc93
  160695: b2951d7
  160687: 90c626b
  160671: ac095b8
  160639: 01d1670
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: ba9e02f862b0540b809ea7c064eb7b4f04fd7512
+refs/heads/master: 60299d75e2ad7e4de6482bfc50f7b5f471c1f55c
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: c9f6d696420107f82304b992cf623b806995fe18
 refs/heads/try: 225de0d60f8ca8dcc62ab2fd8818ebbda4b58cfe

trunk/Makefile.in

@@ -198,6 +198,8 @@ include $(CFG_SRC_DIR)mk/rustllvm.mk
 include $(CFG_SRC_DIR)mk/docs.mk
 # LLVM
 include $(CFG_SRC_DIR)mk/llvm.mk
+# Rules for installing debugger scripts
+include $(CFG_SRC_DIR)mk/debuggers.mk
 
 ######################################################################
 # Secondary makefiles, conditionalized for speed

trunk/mk/clean.mk

@@ -63,6 +63,7 @@ clean-generic-$(2)-$(1):
          -name '*.lib' -o \
          -name '*.dll' -o \
          -name '*.def' -o \
+         -name '*.py' -o \
          -name '*.bc' \
          \) \
          | xargs rm -f
@@ -78,7 +79,7 @@ define CLEAN_HOST_STAGE_N
 
 clean$(1)_H_$(2): \
 	    $$(foreach crate,$$(CRATES),clean$(1)_H_$(2)-lib-$$(crate)) \
-	    $$(foreach tool,$$(TOOLS),clean$(1)_H_$(2)-tool-$$(tool))
+	    $$(foreach tool,$$(TOOLS) $$(DEBUGGER_BIN_SCRIPTS),clean$(1)_H_$(2)-tool-$$(tool))
 	$$(Q)rm -fr $(2)/rt/libbacktrace
 
 clean$(1)_H_$(2)-tool-%:
@@ -98,7 +99,7 @@ define CLEAN_TARGET_STAGE_N
 
 clean$(1)_T_$(2)_H_$(3): \
 	    $$(foreach crate,$$(CRATES),clean$(1)_T_$(2)_H_$(3)-lib-$$(crate)) \
-	    $$(foreach tool,$$(TOOLS),clean$(1)_T_$(2)_H_$(3)-tool-$$(tool))
+	    $$(foreach tool,$$(TOOLS) $$(DEBUGGER_BIN_SCRIPTS),clean$(1)_T_$(2)_H_$(3)-tool-$$(tool))
 	$$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/libmorestack.a
 	$$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/libcompiler-rt.a
 	$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/librun_pass_stage* # For unix

trunk/mk/crates.mk

@@ -50,7 +50,7 @@
 ################################################################################
 
 TARGET_CRATES := libc std flate arena term \
-                 serialize sync getopts collections test time rand \
+                 serialize getopts collections test time rand \
                  log regex graphviz core rbml alloc rustrt \
                  unicode
 HOST_CRATES := syntax rustc rustc_trans rustdoc regex_macros fmt_macros \
@@ -63,7 +63,7 @@ DEPS_libc := core
 DEPS_unicode := core
 DEPS_alloc := core libc native:jemalloc
 DEPS_rustrt := alloc core libc collections native:rustrt_native
-DEPS_std := core libc rand alloc collections rustrt sync unicode \
+DEPS_std := core libc rand alloc collections rustrt unicode \
 	native:rust_builtin native:backtrace
 DEPS_graphviz := std
 DEPS_syntax := std term serialize log fmt_macros arena libc
@@ -81,7 +81,6 @@ DEPS_glob := std
 DEPS_serialize := std log
 DEPS_rbml := std log serialize
 DEPS_term := std log
-DEPS_sync := core alloc rustrt collections
 DEPS_getopts := std
 DEPS_collections := core alloc unicode
 DEPS_num := std

trunk/mk/debuggers.mk

@@ -0,0 +1,59 @@
+# Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+# file at the top-level directory of this distribution and at
+# http://rust-lang.org/COPYRIGHT.
+#
+# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+# option. This file may not be copied, modified, or distributed
+# except according to those terms.
+
+######################################################################
+# Copy debugger related scripts
+######################################################################
+
+DEBUGGER_RUSTLIB_ETC_SCRIPTS=lldb_rust_formatters.py
+DEBUGGER_BIN_SCRIPTS=rust-lldb
+
+DEBUGGER_RUSTLIB_ETC_SCRIPTS_ABS=$(foreach script,$(DEBUGGER_RUSTLIB_ETC_SCRIPTS), \
+                                     $(CFG_SRC_DIR)src/etc/$(script))
+DEBUGGER_BIN_SCRIPTS_ABS=$(foreach script,$(DEBUGGER_BIN_SCRIPTS), \
+                             $(CFG_SRC_DIR)src/etc/$(script))
+
+DEBUGGER_SCRIPTS_ALL=$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_ABS) $(DEBUGGER_BIN_SCRIPTS_ABS)
+
+# $(1) - the stage to copy to
+# $(2) - the host triple
+define DEF_INSTALL_DEBUGGER_SCRIPTS_HOST
+
+tmp/install-debugger-scripts$(1)_H_$(2).done: $$(DEBUGGER_SCRIPTS_ALL)
+	$(Q)mkdir -p $$(HBIN$(1)_H_$(2))
+	$(Q)mkdir -p $$(HLIB$(1)_H_$(2))/rustlib/etc
+	$(Q)install $(DEBUGGER_BIN_SCRIPTS_ABS) $$(HBIN$(1)_H_$(2))
+	$(Q)install $(DEBUGGER_RUSTLIB_ETC_SCRIPTS_ABS) $$(HLIB$(1)_H_$(2))/rustlib/etc
+	$(Q)touch $$@
+endef
+
+# Expand host make-targets for all stages
+$(foreach stage,$(STAGES), \
+  $(foreach host,$(CFG_HOST), \
+    $(eval $(call DEF_INSTALL_DEBUGGER_SCRIPTS_HOST,$(stage),$(host)))))
+
+# $(1) is the stage number
+# $(2) is the target triple
+# $(3) is the host triple
+define DEF_INSTALL_DEBUGGER_SCRIPTS_TARGET
+
+tmp/install-debugger-scripts$(1)_T_$(2)_H_$(3).done: $$(DEBUGGER_SCRIPTS_ALL)
+	$(Q)mkdir -p $$(TBIN$(1)_T_$(2)_H_$(3))
+	$(Q)mkdir -p $$(TLIB$(1)_T_$(2)_H_$(3))/rustlib/etc
+	$(Q)install $(DEBUGGER_BIN_SCRIPTS_ABS) $$(TBIN$(1)_T_$(2)_H_$(3))
+	$(Q)install $(DEBUGGER_RUSTLIB_ETC_SCRIPTS_ABS) $$(TLIB$(1)_T_$(2)_H_$(3))/rustlib/etc
+	$(Q)touch $$@
+endef
+
+# Expand target make-targets for all stages
+$(foreach stage,$(STAGES), \
+  $(foreach target,$(CFG_TARGET), \
+    $(foreach host,$(CFG_HOST), \
+      $(eval $(call DEF_INSTALL_DEBUGGER_SCRIPTS_TARGET,$(stage),$(target),$(host))))))

trunk/mk/main.mk

@@ -356,7 +356,8 @@ HSREQ$(1)_H_$(3) = $$(HBIN$(1)_H_$(3))/rustc$$(X_$(3))
 else
 HSREQ$(1)_H_$(3) = \
 	$$(HBIN$(1)_H_$(3))/rustc$$(X_$(3)) \
-	$$(MKFILE_DEPS)
+	$$(MKFILE_DEPS) \
+	tmp/install-debugger-scripts$(1)_H_$(3).done
 endif
 
 # Prerequisites for using the stageN compiler to build target artifacts
@@ -370,7 +371,8 @@ TSREQ$(1)_T_$(2)_H_$(3) = \
 SREQ$(1)_T_$(2)_H_$(3) = \
 	$$(TSREQ$(1)_T_$(2)_H_$(3)) \
 	$$(foreach dep,$$(TARGET_CRATES), \
-	    $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(dep))
+	    $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(dep)) \
+	tmp/install-debugger-scripts$(1)_T_$(2)_H_$(3).done
 
 # Prerequisites for a working stageN compiler and complete set of target
 # libraries

trunk/mk/prepare.mk

@@ -155,7 +155,7 @@ prepare-base-$(1): PREPARE_DEST_LIB_DIR=$$(PREPARE_DEST_DIR)/$$(CFG_LIBDIR_RELAT
 prepare-base-$(1): PREPARE_DEST_MAN_DIR=$$(PREPARE_DEST_DIR)/share/man/man1
 prepare-base-$(1): prepare-everything-$(1)
 
-prepare-everything-$(1): prepare-host-$(1) prepare-targets-$(1)
+prepare-everything-$(1): prepare-host-$(1) prepare-targets-$(1) prepare-debugger-scripts-$(1)
 
 prepare-host-$(1): prepare-host-tools-$(1)
 
@@ -167,8 +167,13 @@ prepare-host-tools-$(1): \
 prepare-host-dirs-$(1): prepare-maybe-clean-$(1)
 	$$(call PREPARE_DIR,$$(PREPARE_DEST_BIN_DIR))
 	$$(call PREPARE_DIR,$$(PREPARE_DEST_LIB_DIR))
+	$$(call PREPARE_DIR,$$(PREPARE_DEST_LIB_DIR)/rustlib/etc)
 	$$(call PREPARE_DIR,$$(PREPARE_DEST_MAN_DIR))
 
+prepare-debugger-scripts-$(1): prepare-host-dirs-$(1) $(DEBUGGER_SCRIPTS_ALL)
+	$$(Q)$$(PREPARE_BIN_CMD) $(DEBUGGER_BIN_SCRIPTS_ABS) $$(PREPARE_DEST_BIN_DIR)
+	$$(Q)$$(PREPARE_LIB_CMD) $(DEBUGGER_RUSTLIB_ETC_SCRIPTS_ABS) $$(PREPARE_DEST_LIB_DIR)/rustlib/etc
+
 $$(foreach tool,$$(PREPARE_TOOLS), \
   $$(foreach host,$$(CFG_HOST), \
       $$(eval $$(call DEF_PREPARE_HOST_TOOL,$$(tool),$$(PREPARE_STAGE),$$(host),$(1)))))

trunk/src/compiletest/errors.rs

@@ -7,6 +7,7 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
+use self::WhichLine::*;
 
 use std::ascii::AsciiExt;
 use std::io::{BufferedReader, File};
@@ -18,28 +19,74 @@ pub struct ExpectedError {
     pub msg: String,
 }
 
-pub static EXPECTED_PATTERN : &'static str = r"//~(?P<adjusts>\^*)\s*(?P<kind>\S*)\s*(?P<msg>.*)";
+/// Looks for either "//~| KIND MESSAGE" or "//~^^... KIND MESSAGE"
+/// The former is a "follow" that inherits its target from the preceding line;
+/// the latter is an "adjusts" that goes that many lines up.
+///
+/// Goal is to enable tests both like: //~^^^ ERROR go up three
+/// and also //~^ ERROR message one for the preceding line, and
+///          //~| ERROR message two for that same line.
+
+pub static EXPECTED_PATTERN : &'static str =
+    r"//~(?P<follow>\|)?(?P<adjusts>\^*)\s*(?P<kind>\S*)\s*(?P<msg>.*)";
+
+#[deriving(PartialEq, Show)]
+enum WhichLine { ThisLine, FollowPrevious(uint), AdjustBackward(uint) }
 
 // Load any test directives embedded in the file
 pub fn load_errors(re: &Regex, testfile: &Path) -> Vec<ExpectedError> {
     let mut rdr = BufferedReader::new(File::open(testfile).unwrap());
 
+    // `last_nonfollow_error` tracks the most recently seen
+    // line with an error template that did not use the
+    // follow-syntax, "//~| ...".
+    //
+    // (pnkfelix could not find an easy way to compose Iterator::scan
+    // and Iterator::filter_map to pass along this information into
+    // `parse_expected`. So instead I am storing that state here and
+    // updating it in the map callback below.)
+    let mut last_nonfollow_error = None;
+
     rdr.lines().enumerate().filter_map(|(line_no, ln)| {
-        parse_expected(line_no + 1, ln.unwrap().as_slice(), re)
+        parse_expected(last_nonfollow_error,
+                       line_no + 1,
+                       ln.unwrap().as_slice(), re)
+            .map(|(which, error)| {
+                match which {
+                    FollowPrevious(_) => {}
+                    _ => last_nonfollow_error = Some(error.line),
+                }
+                error
+            })
     }).collect()
 }
 
-fn parse_expected(line_num: uint, line: &str, re: &Regex) -> Option<ExpectedError> {
+fn parse_expected(last_nonfollow_error: Option<uint>,
+                  line_num: uint,
+                  line: &str,
+                  re: &Regex) -> Option<(WhichLine, ExpectedError)> {
     re.captures(line).and_then(|caps| {
         let adjusts = caps.name("adjusts").len();
         let kind = caps.name("kind").to_ascii_lower();
         let msg = caps.name("msg").trim().to_string();
+        let follow = caps.name("follow").len() > 0;
+
+        let (which, line) = if follow {
+            assert!(adjusts == 0, "use either //~| or //~^, not both.");
+            let line = last_nonfollow_error.unwrap_or_else(|| {
+                panic!("encountered //~| without preceding //~^ line.")
+            });
+            (FollowPrevious(line), line)
+        } else {
+            let which =
+                if adjusts > 0 { AdjustBackward(adjusts) } else { ThisLine };
+            let line = line_num - adjusts;
+            (which, line)
+        };
 
-        debug!("line={} kind={} msg={}", line_num, kind, msg);
-        Some(ExpectedError {
-            line: line_num - adjusts,
-            kind: kind,
-            msg: msg,
-        })
+        debug!("line={} which={} kind={} msg={}", line_num, which, kind, msg);
+        Some((which, ExpectedError { line: line,
+                                     kind: kind,
+                                     msg: msg, }))
     })
 }

trunk/src/doc/reference.md

@@ -1689,7 +1689,20 @@ methods in such an implementation can only be used as direct calls on the
 values of the type that the implementation targets. In such an implementation,
 the trait type and `for` after `impl` are omitted. Such implementations are
 limited to nominal types (enums, structs), and the implementation must appear
-in the same module or a sub-module as the `self` type.
+in the same module or a sub-module as the `self` type:
+
+```
+struct Point {x: int, y: int}
+
+impl Point {
+    fn log(&self) {
+        println!("Point is at ({}, {})", self.x, self.y);
+    }
+}
+
+let my_point = Point {x: 10, y:11};
+my_point.log();
+```
 
 When a trait _is_ specified in an `impl`, all methods declared as part of the
 trait must be implemented, with matching types and type parameter counts.

trunk/src/etc/emacs/rust-mode.el

@@ -31,9 +31,6 @@
     (modify-syntax-entry ?\" "\"" table)
     (modify-syntax-entry ?\\ "\\" table)
 
-    ;; _ is a word-char
-    (modify-syntax-entry ?_ "w" table)
-
     ;; Comments
     (modify-syntax-entry ?/  ". 124b" table)
     (modify-syntax-entry ?*  ". 23"   table)
@@ -397,7 +394,7 @@ This is written mainly to be used as `beginning-of-defun-function' for Rust.
 Don't move to the beginning of the line. `beginning-of-defun',
 which calls this, does that afterwards."
   (interactive "p")
-  (re-search-backward (concat "^\\(" rust-top-item-beg-re "\\)\\b")
+  (re-search-backward (concat "^\\(" rust-top-item-beg-re "\\)\\_>")
                       nil 'move (or arg 1)))
 
 (defun rust-end-of-defun ()

trunk/src/etc/licenseck.py

@@ -38,10 +38,9 @@
     "rt/isaac/randport.cpp", # public domain
     "rt/isaac/rand.h", # public domain
     "rt/isaac/standard.h", # public domain
-    "libsync/mpsc_queue.rs", # BSD
-    "libsync/spsc_queue.rs", # BSD
-    "libsync/mpmc_bounded_queue.rs", # BSD
-    "libsync/mpsc_intrusive.rs", # BSD
+    "libstd/sync/mpsc_queue.rs", # BSD
+    "libstd/sync/spsc_queue.rs", # BSD
+    "libstd/sync/mpmc_bounded_queue.rs", # BSD
     "test/bench/shootout-binarytrees.rs", # BSD
     "test/bench/shootout-chameneos-redux.rs", # BSD
     "test/bench/shootout-fannkuch-redux.rs", # BSD

trunk/src/etc/lldb_rust_formatters.py

@@ -69,8 +69,14 @@ def print_struct_val_starting_from(field_start_index, val, internal_dict):
   assert val.GetType().GetTypeClass() == lldb.eTypeClassStruct
 
   t = val.GetType()
-  has_field_names = type_has_field_names(t)
   type_name = extract_type_name(t.GetName())
+  num_children = val.num_children
+
+  if (num_children - field_start_index) == 0:
+    # The only field of this struct is the enum discriminant
+    return type_name
+
+  has_field_names = type_has_field_names(t)
 
   if has_field_names:
       template = "%(type_name)s {\n%(body)s\n}"
@@ -83,8 +89,6 @@ def print_struct_val_starting_from(field_start_index, val, internal_dict):
     # this is a tuple, so don't print the type name
     type_name = ""
 
-  num_children = val.num_children
-
   def render_child(child_index):
     this = ""
     if has_field_names:
@@ -105,7 +109,6 @@ def print_enum_val(val, internal_dict):
 
   assert val.GetType().GetTypeClass() == lldb.eTypeClassUnion
 
-
   if val.num_children == 1:
     # This is either an enum with just one variant, or it is an Option-like enum
     # where the discriminant is encoded in a non-nullable pointer field. We find

trunk/src/etc/rust-lldb

@@ -0,0 +1,30 @@
+#!/bin/sh
+# Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+# file at the top-level directory of this distribution and at
+# http://rust-lang.org/COPYRIGHT.
+#
+# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+# option. This file may not be copied, modified, or distributed
+# except according to those terms.
+
+# Exit if anything fails
+set -e
+
+# Create a tempfile containing the LLDB script we want to execute on startup
+TMPFILE=`mktemp /tmp/rust-lldb-commands.XXXXXX`
+
+# Make sure to delete the tempfile no matter what
+trap "rm -f $TMPFILE; exit" INT TERM EXIT
+
+# Find out where to look for the pretty printer Python module
+RUSTC_SYSROOT=`rustc -Zprint-sysroot`
+
+# Write the LLDB script to the tempfile
+echo "command script import \"$RUSTC_SYSROOT/lib/rustlib/etc/lldb_rust_formatters.py\"" >> $TMPFILE
+echo "type summary add --no-value --python-function lldb_rust_formatters.print_val -x \".*\" --category Rust" >> $TMPFILE
+echo "type category enable Rust" >> $TMPFILE
+
+# Call LLDB with the script added to the argument list
+lldb --source-before-file="$TMPFILE" "$@"

trunk/src/libcollections/binary_heap.rs

@@ -585,10 +585,10 @@ impl<T> DoubleEndedIterator<T> for MoveItems<T> {
     fn next_back(&mut self) -> Option<T> { self.iter.next_back() }
 }
 
-impl<T> ExactSize<T> for MoveItems<T> {}
+impl<T> ExactSizeIterator<T> for MoveItems<T> {}
 
 impl<T: Ord> FromIterator<T> for BinaryHeap<T> {
-    fn from_iter<Iter: Iterator<T>>(mut iter: Iter) -> BinaryHeap<T> {
+    fn from_iter<Iter: Iterator<T>>(iter: Iter) -> BinaryHeap<T> {
         let vec: Vec<T> = iter.collect();
         BinaryHeap::from_vec(vec)
     }