---

yaml
---
r: 138412
b: refs/heads/master
c: c29a752
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: c245c5bbad10923b47c9f66d5f0da2913ef11a38
+refs/heads/master: c29a7520e7fb4a5b4d4eccfc594e05793ef6688d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5

trunk/src/libcore/num/mod.rs

@@ -1374,7 +1374,7 @@ macro_rules! checkeddiv_int_impl(
                 if *v == 0 || (*self == $min && *v == -1) {
                     None
                 } else {
-                    Some(self / *v)
+                    Some(*self / *v)
                 }
             }
         }
@@ -1395,7 +1395,7 @@ macro_rules! checkeddiv_uint_impl(
                 if *v == 0 {
                     None
                 } else {
-                    Some(self / *v)
+                    Some(*self / *v)
                 }
             }
         }

trunk/src/libcore/ops.rs

@@ -638,7 +638,7 @@ shr_impl!(uint u8 u16 u32 u64 int i8 i16 i32 i64)
  * ```
  */
 #[lang="index"]
-pub trait Index<Index, Result> {
+pub trait Index<Index, Sized? Result> {
     /// The method for the indexing (`Foo[Bar]`) operation
     fn index<'a>(&'a self, index: &Index) -> &'a Result;
 }

trunk/src/librustc/middle/borrowck/graphviz.rs

@@ -142,8 +142,8 @@ impl<'a, 'tcx> dot::Labeller<'a, Node<'a>, Edge<'a>> for DataflowLabeller<'a, 't
 }
 
 impl<'a, 'tcx> dot::GraphWalk<'a, Node<'a>, Edge<'a>> for DataflowLabeller<'a, 'tcx> {
-    fn nodes(&self) -> dot::Nodes<'a, Node<'a>> { self.inner.nodes() }
-    fn edges(&self) -> dot::Edges<'a, Edge<'a>> { self.inner.edges() }
-    fn source(&self, edge: &Edge<'a>) -> Node<'a> { self.inner.source(edge) }
-    fn target(&self, edge: &Edge<'a>) -> Node<'a> { self.inner.target(edge) }
+    fn nodes(&'a self) -> dot::Nodes<'a, Node<'a>> { self.inner.nodes() }
+    fn edges(&'a self) -> dot::Edges<'a, Edge<'a>> { self.inner.edges() }
+    fn source(&'a self, edge: &Edge<'a>) -> Node<'a> { self.inner.source(edge) }
+    fn target(&'a self, edge: &Edge<'a>) -> Node<'a> { self.inner.target(edge) }
 }

trunk/src/librustc/middle/cfg/graphviz.rs

@@ -91,29 +91,29 @@ impl<'a, 'ast> dot::Labeller<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a, 'ast> {
 }
 
 impl<'a> dot::GraphWalk<'a, Node<'a>, Edge<'a>> for &'a cfg::CFG {
-    fn nodes(&self) -> dot::Nodes<'a, Node<'a>> {
+    fn nodes(&'a self) -> dot::Nodes<'a, Node<'a>> {
         let mut v = Vec::new();
         self.graph.each_node(|i, nd| { v.push((i, nd)); true });
         dot::maybe_owned_vec::Growable(v)
     }
-    fn edges(&self) -> dot::Edges<'a, Edge<'a>> {
+    fn edges(&'a self) -> dot::Edges<'a, Edge<'a>> {
         self.graph.all_edges().iter().collect()
     }
-    fn source(&self, edge: &Edge<'a>) -> Node<'a> {
+    fn source(&'a self, edge: &Edge<'a>) -> Node<'a> {
         let i = edge.source();
         (i, self.graph.node(i))
     }
-    fn target(&self, edge: &Edge<'a>) -> Node<'a> {
+    fn target(&'a self, edge: &Edge<'a>) -> Node<'a> {
         let i = edge.target();
         (i, self.graph.node(i))
     }
 }
 
 impl<'a, 'ast> dot::GraphWalk<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a, 'ast>
 {
-    fn nodes(&self) -> dot::Nodes<'a, Node<'a>> { self.cfg.nodes() }
-    fn edges(&self) -> dot::Edges<'a, Edge<'a>> { self.cfg.edges() }
-    fn source(&self, edge: &Edge<'a>) -> Node<'a> { self.cfg.source(edge) }
-    fn target(&self, edge: &Edge<'a>) -> Node<'a> { self.cfg.target(edge) }
+    fn nodes(&'a self) -> dot::Nodes<'a, Node<'a>> { self.cfg.nodes() }
+    fn edges(&'a self) -> dot::Edges<'a, Edge<'a>> { self.cfg.edges() }
+    fn source(&'a self, edge: &Edge<'a>) -> Node<'a> { self.cfg.source(edge) }
+    fn target(&'a self, edge: &Edge<'a>) -> Node<'a> { self.cfg.target(edge) }
 }
 

trunk/src/librustc/middle/traits/doc.rs

@@ -272,4 +272,11 @@ nested obligation `int : Bar<U>` to find out that `U=uint`.
 It would be good to only do *just as much* nested resolution as
 necessary. Currently, though, we just do a full resolution.
 
+## Method matching
+
+Method dispach follows a slightly different path than normal trait
+selection. This is because it must account for the transformed self
+type of the receiver and various other complications. The procedure is
+described in `select.rs` in the "METHOD MATCHING" section.
+
 */

trunk/src/librustc/middle/traits/mod.rs

@@ -24,6 +24,8 @@ use syntax::codemap::{Span, DUMMY_SP};
 pub use self::fulfill::FulfillmentContext;
 pub use self::select::SelectionContext;
 pub use self::select::SelectionCache;
+pub use self::select::{MethodMatchResult, MethodMatched, MethodAmbiguous, MethodDidNotMatch};
+pub use self::select::{MethodMatchedData}; // intentionally don't export variants
 pub use self::util::supertraits;
 pub use self::util::transitive_bounds;
 pub use self::util::Supertraits;
@@ -219,22 +221,6 @@ pub struct VtableParamData {
     pub bound: Rc<ty::TraitRef>,
 }
 
-pub fn evaluate_obligation<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
-                                    param_env: &ty::ParameterEnvironment,
-                                    obligation: &Obligation,
-                                    typer: &Typer<'tcx>)
-                                    -> bool
-{
-    /*!
-     * Attempts to resolve the obligation given. Returns `None` if
-     * we are unable to resolve, either because of ambiguity or
-     * due to insufficient inference.
-     */
-
-    let mut selcx = select::SelectionContext::new(infcx, param_env, typer);
-    selcx.evaluate_obligation(obligation)
-}
-
 pub fn select_inherent_impl<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
                                      param_env: &ty::ParameterEnvironment,
                                      typer: &Typer<'tcx>,