---

yaml
---
r: 138411
b: refs/heads/master
c: c245c5b
h: refs/heads/master
i:
  138409: 50503bd
  138407: e37c816
v: v3

Author: spernsteiner

[refs]

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

trunk/mk/main.mk

@@ -157,6 +157,13 @@ 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,6 +628,10 @@ 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/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/librustc/driver/config.rs

@@ -780,7 +780,20 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
         early_warn("the --crate-file-name argument has been renamed to \
                     --print-file-name");
     }
-    let cg = build_codegen_options(matches);
+
+    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;
+
 
     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/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>,