---

yaml
---
r: 174394
b: refs/heads/auto
c: 135cac8
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 3f0cc8011aef3f530663302d525bd2d8cb493db5
+refs/heads/auto: 135cac852822afe822cc1e4eb9546b96eb2cb35d
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/liblibc/lib.rs

@@ -2207,10 +2207,10 @@ pub mod consts {
             pub const IPPROTO_TCP: c_int = 6;
             pub const IPPROTO_IP: c_int = 0;
             pub const IPPROTO_IPV6: c_int = 41;
-            pub const IP_MULTICAST_TTL: c_int = 3;
-            pub const IP_MULTICAST_LOOP: c_int = 4;
-            pub const IP_ADD_MEMBERSHIP: c_int = 5;
-            pub const IP_DROP_MEMBERSHIP: c_int = 6;
+            pub const IP_MULTICAST_TTL: c_int = 10;
+            pub const IP_MULTICAST_LOOP: c_int = 11;
+            pub const IP_ADD_MEMBERSHIP: c_int = 12;
+            pub const IP_DROP_MEMBERSHIP: c_int = 13;
             pub const IPV6_ADD_MEMBERSHIP: c_int = 5;
             pub const IPV6_DROP_MEMBERSHIP: c_int = 6;
             pub const IP_TTL: c_int = 4;

branches/auto/src/librustc_typeck/check/method/probe.rs

@@ -44,7 +44,6 @@ struct ProbeContext<'a, 'tcx:'a> {
     extension_candidates: Vec<Candidate<'tcx>>,
     impl_dups: HashSet<ast::DefId>,
     static_candidates: Vec<CandidateSource>,
-    all_traits_search: bool,
 }
 
 struct CandidateStep<'tcx> {
@@ -211,7 +210,6 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
             steps: Rc::new(steps),
             opt_simplified_steps: opt_simplified_steps,
             static_candidates: Vec::new(),
-            all_traits_search: false,
         }
     }
 
@@ -724,60 +722,53 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
     // THE ACTUAL SEARCH
 
     fn pick(mut self) -> PickResult<'tcx> {
-        let steps = self.steps.clone();
-
-        for step in steps.iter() {
-            match self.pick_step(step) {
-                Some(r) => {
-                    return r;
-                }
-                None => { }
-            }
+        match self.pick_core() {
+            Some(r) => return r,
+            None => {}
         }
 
         let static_candidates = mem::replace(&mut self.static_candidates, vec![]);
 
-        let out_of_scope_traits = if !self.all_traits_search {
-            // things failed, and we haven't yet looked through all
-            // traits, so lets do that now:
-            self.reset();
-            self.all_traits_search = true;
-
-            let span = self.span;
-            let tcx = self.tcx();
-
-            self.assemble_extension_candidates_for_all_traits();
-
-            match self.pick() {
-                Ok(p) => vec![p.method_ty.container.id()],
-                Err(Ambiguity(v)) => v.into_iter().map(|source| {
-                    match source {
-                        TraitSource(id) => id,
-                        ImplSource(impl_id) => {
-                            match ty::trait_id_of_impl(tcx, impl_id) {
-                                Some(id) => id,
-                                None => tcx.sess.span_bug(span,
-                                                          "found inherent method when looking \
-                                                           at traits")
-                            }
+        // things failed, so lets look at all traits, for diagnostic purposes now:
+        self.reset();
+
+        let span = self.span;
+        let tcx = self.tcx();
+
+        self.assemble_extension_candidates_for_all_traits();
+
+        let out_of_scope_traits = match self.pick_core() {
+            Some(Ok(p)) => vec![p.method_ty.container.id()],
+            Some(Err(Ambiguity(v))) => v.into_iter().map(|source| {
+                match source {
+                    TraitSource(id) => id,
+                    ImplSource(impl_id) => {
+                        match ty::trait_id_of_impl(tcx, impl_id) {
+                            Some(id) => id,
+                            None =>
+                                tcx.sess.span_bug(span,
+                                                  "found inherent method when looking at traits")
                         }
                     }
-                }).collect(),
-                // it'd be really weird for this assertion to trigger,
-                // given the `vec![]` in the else branch below
-                Err(NoMatch(_, others)) => {
-                    assert!(others.is_empty());
-                    vec![]
                 }
+            }).collect(),
+            Some(Err(NoMatch(_, others))) => {
+                assert!(others.is_empty());
+                vec![]
             }
-        } else {
-            // we've just looked through all traits and didn't find
-            // anything at all.
-            vec![]
+            None => vec![],
         };
+;
         Err(NoMatch(static_candidates, out_of_scope_traits))
     }
 
+    fn pick_core(&mut self) -> Option<PickResult<'tcx>> {
+        let steps = self.steps.clone();
+
+        // find the first step that works
+        steps.iter().filter_map(|step| self.pick_step(step)).next()
+    }
+
     fn pick_step(&mut self, step: &CandidateStep<'tcx>) -> Option<PickResult<'tcx>> {
         debug!("pick_step: step={}", step.repr(self.tcx()));
 

branches/auto/src/librustc_typeck/check/method/suggest.rs

@@ -147,16 +147,16 @@ fn suggest_traits_to_import<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
         candidates.sort();
         let msg = format!(
             "methods from traits can only be called if the trait is in scope; \
-             the following {traits_are} implemented and {define} a method `{name}`:",
+             the following {traits_are} implemented but not in scope, \
+             perhaps add a `use` for {one_of_them}:",
             traits_are = if candidates.len() == 1 {"trait is"} else {"traits are"},
-            define = if candidates.len() == 1 {"defines"} else {"define"},
-            name = method_ustring);
+            one_of_them = if candidates.len() == 1 {"it"} else {"one of them"});
 
         fcx.sess().fileline_help(span, &msg[]);
 
         for (i, trait_did) in candidates.iter().enumerate() {
             fcx.sess().fileline_help(span,
-                                     &*format!("candidate #{}: `{}`",
+                                     &*format!("candidate #{}: use `{}`",
                                                i + 1,
                                                ty::item_path_str(fcx.tcx(), *trait_did)))
 
@@ -174,9 +174,11 @@ fn suggest_traits_to_import<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
         candidates.sort_by(|a, b| a.cmp(b).reverse());
 
         let msg = format!(
-            "methods from traits can only be called if the trait is implemented and \
-             in scope; no such traits are but the following {traits_define} a method `{name}`:",
+            "methods from traits can only be called if the trait is implemented and in scope; \
+             the following {traits_define} a method `{name}`, \
+             perhaps you need to implement {one_of_them}:",
             traits_define = if candidates.len() == 1 {"trait defines"} else {"traits define"},
+            one_of_them = if candidates.len() == 1 {"it"} else {"one of them"},
             name = method_ustring);
 
         fcx.sess().fileline_help(span, &msg[]);

branches/auto/src/libsyntax/parse/parser.rs

@@ -2136,6 +2136,7 @@ impl<'a> Parser<'a> {
 
         let ex: Expr_;
 
+        // Note: when adding new syntax here, don't forget to adjust Token::can_begin_expr().
         match self.token {
             token::OpenDelim(token::Paren) => {
                 self.bump();
@@ -2773,6 +2774,7 @@ impl<'a> Parser<'a> {
         let lo = self.span.lo;
         let hi;
 
+        // Note: when adding new unary operators, don't forget to adjust Token::can_begin_expr()
         let ex;
         match self.token {
           token::Not => {
@@ -5517,13 +5519,6 @@ impl<'a> Parser<'a> {
         (id, ItemEnum(enum_definition, generics), None)
     }
 
-    fn fn_expr_lookahead(tok: &token::Token) -> bool {
-        match *tok {
-          token::OpenDelim(token::Paren) | token::At | token::Tilde | token::BinOp(_) => true,
-          _ => false
-        }
-    }
-
     /// Parses a string as an ABI spec on an extern type or module. Consumes
     /// the `extern` keyword, if one is found.
     fn parse_opt_abi(&mut self) -> Option<abi::Abi> {
@@ -5696,8 +5691,7 @@ impl<'a> Parser<'a> {
                                     maybe_append(attrs, extra_attrs));
             return IoviItem(item);
         }
-        if self.token.is_keyword(keywords::Fn) &&
-                self.look_ahead(1, |f| !Parser::fn_expr_lookahead(f)) {
+        if self.token.is_keyword(keywords::Fn) {
             // FUNCTION ITEM
             self.bump();
             let (ident, item_, extra_attrs) =

branches/auto/src/libsyntax/parse/token.rs

@@ -183,14 +183,14 @@ impl Token {
             Underscore                  => true,
             Tilde                       => true,
             Literal(_, _)               => true,
-            Pound                       => true,
-            At                          => true,
             Not                         => true,
             BinOp(Minus)                => true,
             BinOp(Star)                 => true,
             BinOp(And)                  => true,
             BinOp(Or)                   => true, // in lambda syntax
             OrOr                        => true, // in lambda syntax
+            AndAnd                      => true, // double borrow
+            DotDot                      => true, // range notation
             ModSep                      => true,
             Interpolated(NtExpr(..))    => true,
             Interpolated(NtIdent(..))   => true,

branches/auto/src/test/compile-fail/no-method-suggested-traits.rs

@@ -26,24 +26,24 @@ mod foo {
 
 fn main() {
     1u32.method();
-    //~^ ERROR does not implement
-    //~^^ HELP the following traits are implemented and define a method `method`
+    //~^ HELP following traits are implemented but not in scope, perhaps add a `use` for one of them
+    //~^^ ERROR does not implement
     //~^^^ HELP `foo::Bar`
     //~^^^^ HELP `no_method_suggested_traits::foo::PubPub`
 
     'a'.method();
     //~^ ERROR does not implement
-    //~^^ HELP the following trait is implemented and defines a method `method`
+    //~^^ HELP the following trait is implemented but not in scope, perhaps add a `use` for it:
     //~^^^ HELP `foo::Bar`
 
     1i32.method();
     //~^ ERROR does not implement
-    //~^^ HELP the following trait is implemented and defines a method `method`
+    //~^^ HELP the following trait is implemented but not in scope, perhaps add a `use` for it:
     //~^^^ HELP `no_method_suggested_traits::foo::PubPub`
 
     1u64.method();
     //~^ ERROR does not implement
-    //~^^ HELP the following traits define a method `method`
+    //~^^ HELP following traits define a method `method`, perhaps you need to implement one of them
     //~^^^ HELP `foo::Bar`
     //~^^^^ HELP `no_method_suggested_traits::foo::PubPub`
     //~^^^^^ HELP `no_method_suggested_traits::reexport::Reexported`
@@ -53,10 +53,10 @@ fn main() {
 
     1u64.method2();
     //~^ ERROR does not implement
-    //~^^ HELP the following trait defines a method `method2`
+    //~^^ HELP the following trait defines a method `method2`, perhaps you need to implement it
     //~^^^ HELP `foo::Bar`
     1u64.method3();
     //~^ ERROR does not implement
-    //~^^ HELP the following trait defines a method `method3`
+    //~^^ HELP the following trait defines a method `method3`, perhaps you need to implement it
     //~^^^ HELP `no_method_suggested_traits::foo::PubPub`
 }

branches/auto/src/test/run-pass/range.rs

@@ -12,6 +12,9 @@
 
 fn foo() -> int { 42 }
 
+// Test that range syntax works in return statements
+fn return_range_to() -> ::std::ops::RangeTo<i32> { return ..1; }
+
 pub fn main() {
     let mut count = 0;
     for i in 0u..10 {