---

yaml
---
r: 152178
b: refs/heads/try2
c: 80e84e0
h: refs/heads/master
v: v3

Author: Jakub Wieczorek

[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: b38712071efd09fd602cef6a11621db09672f990
+refs/heads/try2: 80e84e00010ee8a1c924619e6834d4a51eaf0f34
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/crates.mk

@@ -51,7 +51,7 @@
 
 TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
                  uuid serialize sync getopts collections num test time rand \
-                 url log regex graphviz core rlibc alloc debug
+		 workcache url log regex graphviz core rlibc alloc debug
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -88,6 +88,7 @@ DEPS_test := std collections getopts serialize term time regex
 DEPS_time := std serialize sync
 DEPS_rand := core
 DEPS_url := std collections
+DEPS_workcache := std serialize collections log
 DEPS_log := std sync
 DEPS_regex := std collections
 DEPS_regex_macros = syntax std regex

branches/try2/src/doc/guide-ffi.md

@@ -2,11 +2,11 @@
 
 # Introduction
 
-This guide will use the [snappy](https://github.com/google/snappy)
+This guide will use the [snappy](https://code.google.com/p/snappy/)
 compression/decompression library as an introduction to writing bindings for
 foreign code. Rust is currently unable to call directly into a C++ library, but
 snappy includes a C interface (documented in
-[`snappy-c.h`](https://github.com/google/snappy/blob/master/snappy-c.h)).
+[`snappy-c.h`](https://code.google.com/p/snappy/source/browse/trunk/snappy-c.h)).
 
 The following is a minimal example of calling a foreign function which will
 compile if snappy is installed:

branches/try2/src/librustc/middle/borrowck/check_loans.rs

@@ -638,8 +638,8 @@ impl<'a> CheckLoanCtxt<'a> {
                 loan_path = match *loan_path {
                     // Peel back one layer if, for `loan_path` to be
                     // mutable, `lp_base` must be mutable. This occurs
-                    // with inherited mutability, owned pointers and
-                    // `&mut` pointers.
+                    // with inherited mutability and with `&mut`
+                    // pointers.
                     LpExtend(ref lp_base, mc::McInherited, _) |
                     LpExtend(ref lp_base, _, LpDeref(mc::OwnedPtr)) |
                     LpExtend(ref lp_base, _, LpDeref(mc::GcPtr)) |

branches/try2/src/librustc/middle/typeck/check/_match.rs

@@ -298,9 +298,8 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: &ast::Pat, path: &ast::Path,
 /// `etc` is true if the pattern said '...' and false otherwise.
 pub fn check_struct_pat_fields(pcx: &pat_ctxt,
                                span: Span,
-                               path: &ast::Path,
                                fields: &[ast::FieldPat],
-                               class_fields: Vec<ty::field_ty> ,
+                               class_fields: Vec<ty::field_ty>,
                                class_id: ast::DefId,
                                substitutions: &ty::substs,
                                etc: bool) {
@@ -333,13 +332,12 @@ pub fn check_struct_pat_fields(pcx: &pat_ctxt,
                 found_fields.insert(index);
             }
             None => {
-                let name = pprust::path_to_str(path);
                 // Check the pattern anyway, so that attempts to look
                 // up its type won't fail
                 check_pat(pcx, field.pat, ty::mk_err());
                 tcx.sess.span_err(span,
                     format!("struct `{}` does not have a field named `{}`",
-                            name,
+                            ty::item_path_str(tcx, class_id),
                             token::get_ident(field.ident)).as_slice());
             }
         }
@@ -390,7 +388,7 @@ pub fn check_struct_pat(pcx: &pat_ctxt, pat_id: ast::NodeId, span: Span,
         }
     }
 
-    check_struct_pat_fields(pcx, span, path, fields, class_fields, struct_id,
+    check_struct_pat_fields(pcx, span, fields, class_fields, struct_id,
                             substitutions, etc);
 }
 
@@ -413,7 +411,7 @@ pub fn check_struct_like_enum_variant_pat(pcx: &pat_ctxt,
             // Get the struct fields from this struct-like enum variant.
             let class_fields = ty::lookup_struct_fields(tcx, variant_id);
 
-            check_struct_pat_fields(pcx, span, path, fields, class_fields,
+            check_struct_pat_fields(pcx, span, fields, class_fields,
                                     variant_id, substitutions, etc);
         }
         Some(&ast::DefStruct(..)) | Some(&ast::DefVariant(..)) => {

branches/try2/src/librustc/middle/typeck/check/method.rs

@@ -1026,7 +1026,13 @@ impl<'a> LookupContext<'a> {
     fn consider_candidates(&self, rcvr_ty: ty::t,
                            candidates: &[Candidate])
                            -> Option<MethodCallee> {
-        let relevant_candidates = self.filter_candidates(rcvr_ty, candidates);
+        // FIXME(pcwalton): Do we need to clone here?
+        let relevant_candidates: Vec<Candidate> =
+            candidates.iter().map(|c| (*c).clone()).
+                filter(|c| self.is_relevant(rcvr_ty, c)).collect();
+
+        let relevant_candidates =
+            self.merge_candidates(relevant_candidates.as_slice());
 
         if relevant_candidates.len() == 0 {
             return None;
@@ -1063,16 +1069,22 @@ impl<'a> LookupContext<'a> {
         Some(self.confirm_candidate(rcvr_ty, relevant_candidates.get(0)))
     }
 
-    fn filter_candidates(&self, rcvr_ty: ty::t, candidates: &[Candidate]) -> Vec<Candidate> {
-        let mut relevant_candidates: Vec<Candidate> = Vec::new();
+    fn merge_candidates(&self, candidates: &[Candidate]) -> Vec<Candidate> {
+        let mut merged = Vec::new();
+        let mut i = 0;
+        while i < candidates.len() {
+            let candidate_a = &candidates[i];
+
+            let mut skip = false;
 
-        for candidate_a in candidates.iter().filter(|&c| self.is_relevant(rcvr_ty, c)) {
-            // Skip this one if we already have one like it
-            if !relevant_candidates.iter().any(|candidate_b| {
+            let mut j = i + 1;
+            while j < candidates.len() {
+                let candidate_b = &candidates[j];
                 debug!("attempting to merge {} and {}",
                        candidate_a.repr(self.tcx()),
                        candidate_b.repr(self.tcx()));
-                match (&candidate_a.origin, &candidate_b.origin) {
+                let candidates_same = match (&candidate_a.origin,
+                                             &candidate_b.origin) {
                     (&MethodParam(ref p1), &MethodParam(ref p2)) => {
                         let same_trait = p1.trait_id == p2.trait_id;
                         let same_method = p1.method_num == p2.method_num;
@@ -1083,13 +1095,25 @@ impl<'a> LookupContext<'a> {
                         same_trait && same_method && same_param
                     }
                     _ => false
+                };
+                if candidates_same {
+                    skip = true;
+                    break;
                 }
-            }) {
-                relevant_candidates.push(candidate_a.clone());
+                j += 1;
+            }
+
+            i += 1;
+
+            if skip {
+                // There are more than one of these and we need only one
+                continue;
+            } else {
+                merged.push(candidate_a.clone());
             }
         }
 
-        relevant_candidates
+        return merged;
     }
 
     fn confirm_candidate(&self, rcvr_ty: ty::t, candidate: &Candidate)

branches/try2/src/liburl/lib.rs

@@ -452,8 +452,8 @@ fn query_from_str(rawquery: &str) -> Query {
  *
  * ```rust
  * let query = vec!(("title".to_string(), "The Village".to_string()),
- *                  ("north".to_string(), "52.91".to_string()),
- *                  ("west".to_string(), "4.10".to_string()));
+                    ("north".to_string(), "52.91".to_string()),
+                    ("west".to_string(), "4.10".to_string()));
  * println!("{}", url::query_to_str(&query));  // title=The%20Village&north=52.91&west=4.10
  * ```
  */