librustc: Try to resolve before coercions.

src/librustc/back/archive.rs

@@ -110,7 +110,7 @@ impl<'a> Archive<'a> {
                     lto: bool) -> io::IoResult<()> {
         let object = format!("{}.o", name);
         let bytecode = format!("{}.bc.deflate", name);
-        let mut ignore = vec!(METADATA_FILENAME, bytecode.as_slice());
+        let mut ignore = vec!(bytecode.as_slice(), METADATA_FILENAME);
         if lto {
             ignore.push(object.as_slice());
         }

src/librustc/middle/typeck/check/demand.rs

@@ -12,11 +12,14 @@
 use middle::ty;
 use middle::typeck::check::FnCtxt;
 use middle::typeck::infer;
+use middle::typeck::infer::resolve_type;
+use middle::typeck::infer::resolve::try_resolve_tvar_shallow;
 
 use std::result::{Err, Ok};
 use std::result;
 use syntax::ast;
 use syntax::codemap::Span;
+use util::ppaux::Repr;
 
 // Requires that the two types unify, and prints an error message if they
 // don't.
@@ -58,6 +61,13 @@ pub fn eqtype(fcx: &FnCtxt, sp: Span, expected: ty::t, actual: ty::t) {
 // Checks that the type `actual` can be coerced to `expected`.
 pub fn coerce(fcx: &FnCtxt, sp: Span, expected: ty::t, expr: &ast::Expr) {
     let expr_ty = fcx.expr_ty(expr);
+    debug!("demand::coerce(expected = {}, expr_ty = {})",
+           expected.repr(fcx.ccx.tcx),
+           expr_ty.repr(fcx.ccx.tcx));
+    let expected = if ty::type_needs_infer(expected) {
+        resolve_type(fcx.infcx(), expected,
+                     try_resolve_tvar_shallow).unwrap_or(expected)
+    } else { expected };
     match fcx.mk_assignty(expr, expr_ty, expected) {
       result::Ok(()) => { /* ok */ }
       result::Err(ref err) => {

src/test/compile-fail/issue-7573.rs

@@ -24,9 +24,11 @@ impl CrateId {
 }
 
 pub fn remove_package_from_database() {
-    let mut lines_to_use: Vec<&CrateId> = Vec::new(); //~ ERROR cannot infer an appropriate lifetime
+    let mut lines_to_use: Vec<&CrateId> = Vec::new();
     let push_id = |installed_id: &CrateId| {
         lines_to_use.push(installed_id);
+        //~^ ERROR cannot infer an appropriate lifetime for automatic coercion due to
+        // conflicting requirements
     };
     list_database(push_id);
 

src/test/run-pass/issue-14589.rs

@@ -0,0 +1,30 @@
+// 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.
+
+// All 3 expressions should work in that the argument gets
+// coerced to a trait object
+
+fn main() {
+    send::<Box<Foo>>(box Output(0));
+    Test::<Box<Foo>>::foo(box Output(0));
+    Test::<Box<Foo>>.send(box Output(0));
+}
+
+fn send<T>(_: T) {}
+
+struct Test<T>;
+impl<T> Test<T> {
+    fn foo(_: T) {}
+    fn send(&self, _: T) {}
+}
+
+trait Foo {}
+struct Output(int);
+impl Foo for Output {}

src/test/run-pass/issue-4446.rs

@@ -13,9 +13,9 @@ use std::io::println;
 pub fn main() {
     let (tx, rx) = channel();
 
+    tx.send("hello, world");
+
     spawn(proc() {
         println(rx.recv());
     });
-
-    tx.send("hello, world");
 }