src/test/ui/closure-expected-type/expect-fn-supply-fn.rs

// Copyright 2016 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.

fn with_closure_expecting_fn_with_free_region<F>(_: F)
    where F: for<'a> FnOnce(fn(&'a u32), &i32)
{
}

fn with_closure_expecting_fn_with_bound_region<F>(_: F)
    where F: FnOnce(fn(&u32), &i32)
{
}

fn expect_free_supply_free_from_fn<'x>(x: &'x u32) {
    // Here, the type given for `'x` "obscures" a region from the
    // expected signature that is bound at closure level.
    with_closure_expecting_fn_with_free_region(|x: fn(&'x u32), y| {});
    //~^ ERROR mismatched types
    //~| ERROR mismatched types
}

fn expect_free_supply_free_from_closure() {
    // A variant on the previous test. Here, the region `'a` will be
    // bound at the closure level, just as is expected, so no error
    // results.
    type Foo<'a> = fn(&'a u32);
    with_closure_expecting_fn_with_free_region(|_x: Foo<'_>, y| {});
}

fn expect_free_supply_bound() {
    // Here, we are given a function whose region is bound at closure level,
    // but we expect one bound in the argument. Error results.
    with_closure_expecting_fn_with_free_region(|x: fn(&u32), y| {});
    //~^ ERROR type mismatch in closure arguments
}

fn expect_bound_supply_free_from_fn<'x>(x: &'x u32) {
    // Here, we are given a `fn(&u32)` but we expect a `fn(&'x
    // u32)`. In principle, this could be ok, but we demand equality.
    with_closure_expecting_fn_with_bound_region(|x: fn(&'x u32), y| {});
    //~^ ERROR type mismatch in closure arguments
}

fn expect_bound_supply_free_from_closure() {
    // A variant on the previous test. Here, the region `'a` will be
    // bound at the closure level, but we expect something bound at
    // the argument level.
    type Foo<'a> = fn(&'a u32);
    with_closure_expecting_fn_with_bound_region(|_x: Foo<'_>, y| {});
    //~^ ERROR type mismatch in closure arguments
}

fn expect_bound_supply_bound<'x>(x: &'x u32) {
    // No error in this case. The supplied type supplies the bound
    // regions, and hence we are able to figure out the type of `y`
    // from the expected type
    with_closure_expecting_fn_with_bound_region(|x: for<'z> fn(&'z u32), y| {
    });
}

fn main() { }