Skip to content

Commit

Permalink
auto merge of #18022 : nikomatsakis/rust/issue-18019, r=pcwalton
Browse files Browse the repository at this point in the history
Only consider impliciy unboxed closure impl if the obligation is actually for `Fn`, `FnMut`, or `FnOnce`.

Fixes #18019

r? @pcwalton
  • Loading branch information
bors committed Oct 18, 2014
2 parents 1270f8e + f4a7d32 commit 2c0f876
Show file tree
Hide file tree
Showing 3 changed files with 56 additions and 36 deletions.
49 changes: 20 additions & 29 deletions src/librustc/middle/traits/select.rs
Original file line number Diff line number Diff line change
Expand Up @@ -608,6 +608,17 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
* unified during the confirmation step.
*/

let tcx = self.tcx();
let kind = if Some(obligation.trait_ref.def_id) == tcx.lang_items.fn_trait() {
ty::FnUnboxedClosureKind
} else if Some(obligation.trait_ref.def_id) == tcx.lang_items.fn_mut_trait() {
ty::FnMutUnboxedClosureKind
} else if Some(obligation.trait_ref.def_id) == tcx.lang_items.fn_once_trait() {
ty::FnOnceUnboxedClosureKind
} else {
return Ok(()); // not a fn trait, ignore
};

let self_ty = self.infcx.shallow_resolve(obligation.self_ty());
let closure_def_id = match ty::get(self_ty).sty {
ty::ty_unboxed_closure(id, _) => id,
Expand All @@ -622,37 +633,17 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
self_ty.repr(self.tcx()),
obligation.repr(self.tcx()));

let tcx = self.tcx();
let fn_traits = [
(ty::FnUnboxedClosureKind, tcx.lang_items.fn_trait()),
(ty::FnMutUnboxedClosureKind, tcx.lang_items.fn_mut_trait()),
(ty::FnOnceUnboxedClosureKind, tcx.lang_items.fn_once_trait()),
];
for tuple in fn_traits.iter() {
let kind = match tuple {
&(kind, Some(ref fn_trait))
if *fn_trait == obligation.trait_ref.def_id =>
{
kind
}
_ => continue,
};

// Check to see whether the argument and return types match.
let closure_kind = match self.typer.unboxed_closures().borrow().find(&closure_def_id) {
Some(closure) => closure.kind,
None => {
self.tcx().sess.span_bug(
obligation.cause.span,
format!("No entry for unboxed closure: {}",
closure_def_id.repr(self.tcx())).as_slice());
}
};

if closure_kind != kind {
continue;
let closure_kind = match self.typer.unboxed_closures().borrow().find(&closure_def_id) {
Some(closure) => closure.kind,
None => {
self.tcx().sess.span_bug(
obligation.cause.span,
format!("No entry for unboxed closure: {}",
closure_def_id.repr(self.tcx())).as_slice());
}
};

if closure_kind == kind {
candidates.vec.push(UnboxedClosureCandidate(closure_def_id));
}

Expand Down
11 changes: 4 additions & 7 deletions src/test/compile-fail/type-params-in-different-spaces-2.rs
Original file line number Diff line number Diff line change
Expand Up @@ -8,28 +8,25 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.

// Test static calls to make sure that we align the Self and input
// type parameters on a trait correctly.

trait Tr<T> {
fn op(T) -> Self;
}

// these compile as if Self: Tr<U>, even tho only Self: Tr<Self or T>
trait A: Tr<Self> {
fn test<U>(u: U) -> Self {
Tr::op(u) //~ ERROR not implemented
}
}

trait B<T>: Tr<T> {
fn test<U>(u: U) -> Self {
Tr::op(u) //~ ERROR not implemented
}
}

impl<T> Tr<T> for T {
fn op(t: T) -> T { t }
}
impl<T> A for T {}

fn main() {
std::io::println(A::test((&7306634593706211700, 8)));
}

32 changes: 32 additions & 0 deletions src/test/run-pass/multidispatch-infer-from-single-impl.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,32 @@
// 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.

// Test that we correctly infer that `E` must be `()` here. This is
// known because there is just one impl that could apply where
// `Self=()`.

pub trait FromError<E> {
fn from_error(err: E) -> Self;
}

impl<E> FromError<E> for E {
fn from_error(err: E) -> E {
err
}
}

fn test() -> Result<(), ()> {
Err(FromError::from_error(()))
}

fn main() {
let result = (|| Err(FromError::from_error(())))();
let foo: () = result.unwrap_or(());
}

0 comments on commit 2c0f876

Please sign in to comment.