---

yaml
---
r: 156503
b: refs/heads/master
c: 370c9c5
h: refs/heads/master
i:
  156501: ee9b75c
  156499: 323dee2
  156495: 0d54a89
v: v3

Author: tomjakubowski

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 1d647564b1e575b3ca1e56aee33e3376a8e43772
+refs/heads/master: 370c9c54c2e9b9a308b4fa2a48460e0d54794729
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: d44ea720fa9dfe062ef06d0eb49a58d4e7e92344
 refs/heads/try: 6601b0501e31d08d3892a2d5a7d8a57ab120bf75

trunk/mk/main.mk

@@ -157,13 +157,6 @@ RUSTFLAGS_STAGE1 += -C prefer-dynamic
 # by not emitting them.
 RUSTFLAGS_STAGE0 += -Z no-landing-pads
 
-# Go fast for stage0, and also for stage1/stage2 if optimization is off.
-RUSTFLAGS_STAGE0 += -C codegen-units=4
-ifdef CFG_DISABLE_OPTIMIZE
-	RUSTFLAGS_STAGE1 += -C codegen-units=4
-	RUSTFLAGS_STAGE2 += -C codegen-units=4
-endif
-
 # platform-specific auto-configuration
 include $(CFG_SRC_DIR)mk/platform.mk
 

trunk/mk/tests.mk

@@ -628,10 +628,6 @@ CTEST_RUSTC_FLAGS := $$(subst -O,,$$(CTEST_RUSTC_FLAGS))
 ifndef CFG_DISABLE_OPTIMIZE_TESTS
 CTEST_RUSTC_FLAGS += -O
 endif
-# Force codegen-units=1 for compiletest tests.  compiletest does its own
-# parallelization internally, so rustc's default codegen-units=2 will actually
-# slow things down.
-CTEST_RUSTC_FLAGS += -C codegen-units=1
 
 CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) := \
 		--compile-lib-path $$(HLIB$(1)_H_$(3)) \

trunk/src/doc/guide.md

@@ -4326,7 +4326,7 @@ The most common consumer is `collect()`. This code doesn't quite compile,
 but it shows the intention:
 
 ```{rust,ignore}
-let one_to_one_hundred = range(1i, 101i).collect();
+let one_to_one_hundred = range(0i, 100i).collect();
 ```
 
 As you can see, we call `collect()` on our iterator. `collect()` takes
@@ -4336,7 +4336,7 @@ type of things you want to collect, and so you need to let it know.
 Here's the version that does compile:
 
 ```{rust}
-let one_to_one_hundred = range(1i, 101i).collect::<Vec<int>>();
+let one_to_one_hundred = range(0i, 100i).collect::<Vec<int>>();
 ```
 
 If you remember, the `::<>` syntax allows us to give a type hint,

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, Sized? Result> {
+pub trait Index<Index, Result> {
     /// The method for the indexing (`Foo[Bar]`) operation
     fn index<'a>(&'a self, index: &Index) -> &'a Result;
 }

trunk/src/libcore/option.rs

@@ -245,7 +245,7 @@ impl<T> Option<T> {
     /// ```
     /// let mut x = Some(2u);
     /// match x.as_mut() {
-    ///     Some(v) => *v = 42,
+    ///     Some(&ref mut v) => *v = 42,
     ///     None => {},
     /// }
     /// assert_eq!(x, Some(42u));

trunk/src/librustc/driver/config.rs

@@ -780,20 +780,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
         early_warn("the --crate-file-name argument has been renamed to \
                     --print-file-name");
     }
-
-    let mut cg = build_codegen_options(matches);
-
-    if cg.codegen_units == 0 {
-        match opt_level {
-            // `-C lto` doesn't work with multiple codegen units.
-            _ if cg.lto => cg.codegen_units = 1,
-
-            No | Less => cg.codegen_units = 2,
-            Default | Aggressive => cg.codegen_units = 1,
-        }
-    }
-    let cg = cg;
-
+    let cg = build_codegen_options(matches);
 
     if !cg.remark.is_empty() && debuginfo == NoDebugInfo {
         early_warn("-C remark will not show source locations without --debuginfo");

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(&'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) }
+    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) }
 }

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(&'a self) -> dot::Nodes<'a, Node<'a>> {
+    fn nodes(&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(&'a self) -> dot::Edges<'a, Edge<'a>> {
+    fn edges(&self) -> dot::Edges<'a, Edge<'a>> {
         self.graph.all_edges().iter().collect()
     }
-    fn source(&'a self, edge: &Edge<'a>) -> Node<'a> {
+    fn source(&self, edge: &Edge<'a>) -> Node<'a> {
         let i = edge.source();
         (i, self.graph.node(i))
     }
-    fn target(&'a self, edge: &Edge<'a>) -> Node<'a> {
+    fn target(&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(&'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) }
+    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) }
 }
 

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

@@ -67,9 +67,9 @@ pub fn impl_is_local(tcx: &ty::ctxt,
         return true;
     }
 
-    // Otherwise, at least one of the input types must be local to the
-    // crate.
-    trait_ref.input_types().iter().any(|&t| ty_is_local(tcx, t))
+    // Otherwise, self type must be local to the crate.
+    let self_ty = ty::lookup_item_type(tcx, impl_def_id).ty;
+    return ty_is_local(tcx, self_ty);
 }
 
 pub fn ty_is_local(tcx: &ty::ctxt,

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

@@ -272,11 +272,4 @@ 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,8 +24,6 @@ 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;
@@ -221,6 +219,22 @@ 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>,