---

yaml
---
r: 156541
b: refs/heads/auto
c: aeba2cc
h: refs/heads/master
i:
  156539: 8055bc0
v: v3

Author: nikomatsakis

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 7088c45ef4078e0be54d4353b2c11146e25b2906
+refs/heads/auto: aeba2ccf3082522f56e9aaefc0a961e2ed737f53
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/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
 

branches/auto/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)) \

branches/auto/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");

branches/auto/src/librustc/middle/traits/coherence.rs

@@ -67,9 +67,9 @@ pub fn impl_is_local(tcx: &ty::ctxt,
         return true;
     }
 
-    // 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);
+    // 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))
 }
 
 pub fn ty_is_local(tcx: &ty::ctxt,

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

@@ -721,7 +721,7 @@ pub fn integer_lit(s: &str, sd: &SpanHandler, sp: Span) -> ast::Lit_ {
 mod test {
     use super::*;
     use serialize::json;
-    use codemap::{Span, BytePos, Pos, Spanned, NO_EXPANSION};
+    use codemap::{Span, BytePos, Spanned, NO_EXPANSION};
     use owned_slice::OwnedSlice;
     use ast;
     use abi;
@@ -1121,46 +1121,6 @@ mod test {
                             span: sp(0,21)})));
     }
 
-    fn get_spans_of_pat_idents(src: &str) -> Vec<Span> {
-        let item = string_to_item(src.to_string()).unwrap();
-
-        struct PatIdentVisitor {
-            spans: Vec<Span>
-        }
-        impl<'v> ::visit::Visitor<'v> for PatIdentVisitor {
-            fn visit_pat(&mut self, p: &'v ast::Pat) {
-                match p.node {
-                    ast::PatIdent(_ , ref spannedident, _) => {
-                        self.spans.push(spannedident.span.clone());
-                    }
-                    _ => {
-                        ::visit::walk_pat(self, p);
-                    }
-                }
-            }
-        }
-        let mut v = PatIdentVisitor { spans: Vec::new() };
-        ::visit::walk_item(&mut v, &*item);
-        return v.spans;
-    }
-
-    #[test] fn span_of_self_arg_pat_idents_are_correct() {
-
-        let srcs = ["impl z { fn a (&self, &myarg: int) {} }",
-                    "impl z { fn a (&mut self, &myarg: int) {} }",
-                    "impl z { fn a (&'a self, &myarg: int) {} }",
-                    "impl z { fn a (self, &myarg: int) {} }",
-                    "impl z { fn a (self: Foo, &myarg: int) {} }",
-                    ];
-
-        for &src in srcs.iter() {
-            let spans = get_spans_of_pat_idents(src);
-            let Span{lo:lo,hi:hi,..} = spans[0];
-            assert!("self" == src.slice(lo.to_uint(), hi.to_uint()),
-                    "\"{}\" != \"self\". src=\"{}\"",
-                    src.slice(lo.to_uint(), hi.to_uint()), src)
-        }
-    }
 
     #[test] fn parse_exprs () {
         // just make sure that they parse....

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

@@ -4165,16 +4165,10 @@ impl<'a> Parser<'a> {
         // A bit of complexity and lookahead is needed here in order to be
         // backwards compatible.
         let lo = self.span.lo;
-        let mut self_ident_lo = self.span.lo;
-        let mut self_ident_hi = self.span.hi;
-
         let mut mutbl_self = MutImmutable;
         let explicit_self = match self.token {
             token::BINOP(token::AND) => {
-                let eself = maybe_parse_borrowed_explicit_self(self);
-                self_ident_lo = self.last_span.lo;
-                self_ident_hi = self.last_span.hi;
-                eself
+                maybe_parse_borrowed_explicit_self(self)
             }
             token::TILDE => {
                 // We need to make sure it isn't a type
@@ -4246,7 +4240,7 @@ impl<'a> Parser<'a> {
             _ => SelfStatic,
         };
 
-        let explicit_self_sp = mk_sp(self_ident_lo, self_ident_hi);
+        let explicit_self_sp = mk_sp(lo, self.span.hi);
 
         // shared fall-through for the three cases below. borrowing prevents simply
         // writing this as a closure

branches/auto/src/test/auxiliary/coherence-orphan-lib.rs

@@ -0,0 +1,14 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub trait TheTrait<T> {
+    fn the_fn(&self);
+}
+

branches/auto/src/test/compile-fail/coherence-orphan.rs

@@ -0,0 +1,25 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:coherence-orphan-lib.rs
+
+extern crate "coherence-orphan-lib" as lib;
+
+use lib::TheTrait;
+
+struct TheType;
+
+impl TheTrait<uint> for int { } //~ ERROR E0117
+
+impl TheTrait<TheType> for int { }
+
+impl TheTrait<int> for TheType { }
+
+fn main() { }