From 053383dbeff008744fb5dea7c1c8f4fba98cc06e Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 6 Oct 2017 06:06:38 -0400 Subject: [PATCH] new rules for merging expected/supplied types in closure signatures Also, fix numbering in mir-opt tests. We are now anonymizing more consistently, I think, and hence some of the `TyAnon` indices shifted. --- src/librustc_typeck/check/closure.rs | 274 +++++++++++++----- src/librustc_typeck/lib.rs | 1 + .../closure-expected-type/README.md | 1 + .../expect-fn-supply-fn-multiple.rs | 49 ++++ .../expect-fn-supply-fn.rs | 70 +++++ .../expect-infer-var-appearing-twice.rs | 35 +++ ...t-infer-var-supply-ty-with-bound-region.rs | 29 ++ ...ct-infer-var-supply-ty-with-free-region.rs | 29 ++ .../expect-region-supply-region.rs | 80 +++++ ...-infer-vars-supply-ty-with-bound-region.rs | 29 ++ src/test/mir-opt/validate_1.rs | 2 +- src/test/mir-opt/validate_4.rs | 4 +- src/test/mir-opt/validate_5.rs | 2 +- .../run-pass/closure-expected-type/README.md | 8 + .../expect-infer-supply-two-infers.rs | 26 ++ .../closure-expected-type/issue-38714.rs | 26 ++ .../supply-just-return-type.rs | 35 +++ .../closure-expected-type/supply-nothing.rs | 20 ++ 18 files changed, 649 insertions(+), 71 deletions(-) create mode 100644 src/test/compile-fail/closure-expected-type/README.md create mode 100644 src/test/compile-fail/closure-expected-type/expect-fn-supply-fn-multiple.rs create mode 100644 src/test/compile-fail/closure-expected-type/expect-fn-supply-fn.rs create mode 100644 src/test/compile-fail/closure-expected-type/expect-infer-var-appearing-twice.rs create mode 100644 src/test/compile-fail/closure-expected-type/expect-infer-var-supply-ty-with-bound-region.rs create mode 100644 src/test/compile-fail/closure-expected-type/expect-infer-var-supply-ty-with-free-region.rs create mode 100644 src/test/compile-fail/closure-expected-type/expect-region-supply-region.rs create mode 100644 src/test/compile-fail/closure-expected-type/expect-two-infer-vars-supply-ty-with-bound-region.rs create mode 100644 src/test/run-pass/closure-expected-type/README.md create mode 100644 src/test/run-pass/closure-expected-type/expect-infer-supply-two-infers.rs create mode 100644 src/test/run-pass/closure-expected-type/issue-38714.rs create mode 100644 src/test/run-pass/closure-expected-type/supply-just-return-type.rs create mode 100644 src/test/run-pass/closure-expected-type/supply-nothing.rs diff --git a/src/librustc_typeck/check/closure.rs b/src/librustc_typeck/check/closure.rs index fac2119cb44..df0f3a98858 100644 --- a/src/librustc_typeck/check/closure.rs +++ b/src/librustc_typeck/check/closure.rs @@ -13,14 +13,22 @@ use super::{check_fn, Expectation, FnCtxt}; use astconv::AstConv; +use rustc::hir::def_id::DefId; +use rustc::infer::LateBoundRegionConversionTime; use rustc::infer::type_variable::TypeVariableOrigin; use rustc::ty::{self, ToPolyTraitRef, Ty}; use rustc::ty::subst::Substs; +use rustc::ty::TypeFoldable; use std::cmp; use std::iter; use syntax::abi::Abi; use rustc::hir; +struct ClosureSignatures<'tcx> { + bound_sig: ty::PolyFnSig<'tcx>, + liberated_sig: ty::FnSig<'tcx>, +} + impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { pub fn check_expr_closure(&self, expr: &hir::Expr, @@ -56,15 +64,13 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { expected_sig); let expr_def_id = self.tcx.hir.local_def_id(expr.id); - let sig = self.ty_of_closure(decl, expected_sig); - debug!("check_closure: ty_of_closure returns {:?}", sig); + let ClosureSignatures { bound_sig, liberated_sig } = + self.sig_of_closure(expr_def_id, decl, body, expected_sig); - // `deduce_expectations_from_expected_type` introduces late-bound - // lifetimes defined elsewhere, which we need to anonymize away. - let sig = self.tcx.anonymize_late_bound_regions(&sig); + debug!("check_closure: ty_of_closure returns {:?}", liberated_sig); - debug!("check_closure: anonymized sig={:?}", sig); + let interior = check_fn(self, self.param_env, liberated_sig, decl, expr.id, body, true).1; // Create type variables (for now) to represent the transformed // types of upvars. These will be unified during the upvar @@ -75,14 +81,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { |_, _| span_bug!(expr.span, "closure has region param"), |_, _| self.infcx.next_ty_var(TypeVariableOrigin::TransformedUpvar(expr.span)) ); - - let fn_sig = self.liberate_late_bound_regions(expr_def_id, &sig); - let fn_sig = self.inh.normalize_associated_types_in(body.value.span, - body.value.id, - self.param_env, - &fn_sig); - - let interior = check_fn(self, self.param_env, fn_sig, decl, expr.id, body, true).1; + let closure_type = self.tcx.mk_closure(expr_def_id, substs); if let Some(interior) = interior { let closure_substs = ty::ClosureSubsts { @@ -91,13 +90,11 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { return self.tcx.mk_generator(expr_def_id, closure_substs, interior); } - let closure_type = self.tcx.mk_closure(expr_def_id, substs); - debug!("check_closure: expr.id={:?} closure_type={:?}", expr.id, closure_type); // Tuple up the arguments and insert the resulting function type into // the `closures` table. - let sig = sig.map_bound(|sig| self.tcx.mk_fn_sig( + let sig = bound_sig.map_bound(|sig| self.tcx.mk_fn_sig( iter::once(self.tcx.intern_tup(sig.inputs(), false)), sig.output(), sig.variadic, @@ -271,71 +268,214 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { } } + fn sig_of_closure(&self, + expr_def_id: DefId, + decl: &hir::FnDecl, + body: &hir::Body, + expected_sig: Option>) + -> ClosureSignatures<'tcx> + { + if let Some(e) = expected_sig { + self.sig_of_closure_with_expectation(expr_def_id, decl, body, e) + } else { + self.sig_of_closure_no_expectation(expr_def_id, decl, body) + } + } + + /// If there is no expected signature, then we will convert the + /// types that the user gave into a signature. + fn sig_of_closure_no_expectation(&self, + expr_def_id: DefId, + decl: &hir::FnDecl, + body: &hir::Body) + -> ClosureSignatures<'tcx> + { + debug!("sig_of_closure_no_expectation()"); + + let bound_sig = self.supplied_sig_of_closure(decl); + + self.closure_sigs(expr_def_id, body, bound_sig) + } + /// Invoked to compute the signature of a closure expression. This /// combines any user-provided type annotations (e.g., `|x: u32| /// -> u32 { .. }`) with the expected signature. /// - /// The arguments here are a bit odd-ball: + /// The approach is as follows: /// + /// - Let `S` be the (higher-ranked) signature that we derive from the user's annotations. + /// - Let `E` be the (higher-ranked) signature that we derive from the expectations, if any. + /// - If we have no expectation `E`, then the signature of the closure is `S`. + /// - Otherwise, the signature of the closure is E. Moreover: + /// - Skolemize the late-bound regions in `E`, yielding `E'`. + /// - Instantiate all the late-bound regions bound in the closure within `S` + /// with fresh (existential) variables, yielding `S'` + /// - Require that `E' = S'` + /// - We could use some kind of subtyping relationship here, + /// I imagine, but equality is easier and works fine for + /// our purposes. + /// + /// The key intuition here is that the user's types must be valid + /// from "the inside" of the closure, but the expectation + /// ultimately drives the overall signature. + /// + /// # Examples + /// + /// ``` + /// fn with_closure(_: F) + /// where F: Fn(&u32) -> &u32 { .. } + /// + /// with_closure(|x: &u32| { ... }) + /// ``` + /// + /// Here: + /// - E would be `fn(&u32) -> &u32`. + /// - S would be `fn(&u32) -> + /// - E' is `&'!0 u32 -> &'!0 u32` + /// - S' is `&'?0 u32 -> ?T` + /// + /// S' can be unified with E' with `['?0 = '!0, ?T = &'!10 u32]`. + /// + /// # Arguments + /// + /// - `expr_def_id`: the def-id of the closure expression /// - `decl`: the HIR declaration of the closure + /// - `body`: the body of the closure /// - `expected_sig`: the expected signature (if any). Note that /// this is missing a binder: that is, there may be late-bound /// regions with depth 1, which are bound then by the closure. - fn ty_of_closure(&self, - decl: &hir::FnDecl, - expected_sig: Option>) - -> ty::PolyFnSig<'tcx> + fn sig_of_closure_with_expectation(&self, + expr_def_id: DefId, + decl: &hir::FnDecl, + body: &hir::Body, + expected_sig: ty::FnSig<'tcx>) + -> ClosureSignatures<'tcx> + { + debug!("sig_of_closure_with_expectation(expected_sig={:?})", expected_sig); + + // Watch out for some surprises and just ignore the + // expectation if things don't see to match up with what we + // expect. + if expected_sig.variadic != decl.variadic { + return self.sig_of_closure_no_expectation(expr_def_id, decl, body); + } else if expected_sig.inputs_and_output.len() != decl.inputs.len() + 1 { + // we could probably handle this case more gracefully + return self.sig_of_closure_no_expectation(expr_def_id, decl, body); + } + + // Create a `PolyFnSig`. Note the oddity that late bound + // regions appearing free in `expected_sig` are now bound up + // in this binder we are creating. + assert!(!expected_sig.has_regions_escaping_depth(1)); + let bound_sig = + ty::Binder(self.tcx.mk_fn_sig( + expected_sig.inputs().iter().cloned(), + expected_sig.output(), + decl.variadic, + hir::Unsafety::Normal, + Abi::RustCall)); + + // `deduce_expectations_from_expected_type` introduces + // late-bound lifetimes defined elsewhere, which we now + // anonymize away, so as not to confuse the user. + let bound_sig = self.tcx.anonymize_late_bound_regions(&bound_sig); + + let closure_sigs = self.closure_sigs(expr_def_id, body, bound_sig); + + // Up till this point, we have ignored the annotations that the user + // gave. This function will check that they unify successfully. + // Along the way, it also writes out entries for types that the user + // wrote into our tables, which are then later used by the privacy + // check. + self.check_supplied_sig_against_expectation(decl, &closure_sigs); + + closure_sigs + } + + /// Enforce the user's types against the expectation. See + /// `sig_of_closure_with_expectation` for details on the overall + /// strategy. + fn check_supplied_sig_against_expectation(&self, + decl: &hir::FnDecl, + expected_sigs: &ClosureSignatures<'tcx>) + { + // Get the signature S that the user gave. + // + // (See comment on `sig_of_closure_with_expectation` for the + // meaning of these letters.) + let supplied_sig = self.supplied_sig_of_closure(decl); + + debug!("check_supplied_sig_against_expectation: supplied_sig={:?}", + supplied_sig); + + // The liberated version of this signature should be be a subtype + // of the liberated form of the expectation. + for ((hir_ty, &supplied_ty), expected_ty) in + decl.inputs.iter() + .zip(*supplied_sig.inputs().skip_binder()) // binder moved to (*) below + .zip(expected_sigs.liberated_sig.inputs()) // `liberated_sig` is E'. + { + // Instantiate (this part of..) S to S', i.e., with fresh variables. + let (supplied_ty, _) = self.infcx.replace_late_bound_regions_with_fresh_var( + hir_ty.span, + LateBoundRegionConversionTime::FnCall, + &ty::Binder(supplied_ty)); // recreated from (*) above + + // Check that E' = S'. + self.demand_eqtype(hir_ty.span, expected_ty, supplied_ty); + } + + let (supplied_output_ty, _) = self.infcx.replace_late_bound_regions_with_fresh_var( + decl.output.span(), + LateBoundRegionConversionTime::FnCall, + &supplied_sig.output()); + self.demand_eqtype(decl.output.span(), + expected_sigs.liberated_sig.output(), + supplied_output_ty); + } + + /// If there is no expected signature, then we will convert the + /// types that the user gave into a signature. + fn supplied_sig_of_closure(&self, + decl: &hir::FnDecl) + -> ty::PolyFnSig<'tcx> { let astconv: &AstConv = self; - debug!("ty_of_closure(expected_sig={:?})", - expected_sig); - - let input_tys = decl.inputs.iter().enumerate().map(|(i, a)| { - let expected_arg_ty = expected_sig.as_ref().and_then(|e| { - // no guarantee that the correct number of expected args - // were supplied - if i < e.inputs().len() { - Some(e.inputs()[i]) - } else { - None - } - }); - - let input_ty = astconv.ty_of_arg(a, expected_arg_ty); - debug!("ty_of_closure: i={} input_ty={:?} expected_arg_ty={:?}", - i, input_ty, expected_arg_ty); - - input_ty - }); - - let expected_ret_ty = expected_sig.as_ref().map(|e| e.output()); - - let output_ty = match decl.output { - hir::Return(ref output) => { - if let (&hir::TyInfer, Some(expected_ret_ty)) = (&output.node, expected_ret_ty) { - astconv.record_ty(output.hir_id, expected_ret_ty, output.span); - expected_ret_ty - } else { - astconv.ast_ty_to_ty(&output) - } - } - hir::DefaultReturn(span) => { - if let Some(expected_ret_ty) = expected_ret_ty { - expected_ret_ty - } else { - astconv.ty_infer(span) - } - } + // First, convert the types that the user supplied (if any). + let supplied_arguments = + decl.inputs + .iter() + .map(|a| astconv.ast_ty_to_ty(a)); + let supplied_return = match decl.output { + hir::Return(ref output) => astconv.ast_ty_to_ty(&output), + hir::DefaultReturn(_) => astconv.ty_infer(decl.output.span()), }; - debug!("ty_of_closure: output_ty={:?}", output_ty); - - ty::Binder(self.tcx.mk_fn_sig( - input_tys, - output_ty, + let result = ty::Binder(self.tcx.mk_fn_sig( + supplied_arguments, + supplied_return, decl.variadic, hir::Unsafety::Normal, - Abi::RustCall)) + Abi::RustCall)); + + debug!("supplied_sig_of_closure: result={:?}", result); + + result + } + + fn closure_sigs(&self, + expr_def_id: DefId, + body: &hir::Body, + bound_sig: ty::PolyFnSig<'tcx>) + -> ClosureSignatures<'tcx> + { + let liberated_sig = self.liberate_late_bound_regions(expr_def_id, &bound_sig); + let liberated_sig = self.inh.normalize_associated_types_in(body.value.span, + body.value.id, + self.param_env, + &liberated_sig); + ClosureSignatures { bound_sig, liberated_sig } } } + diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 49ba0499f78..5227955d7b9 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -76,6 +76,7 @@ This API is completely unstable and subject to change. #![feature(box_patterns)] #![feature(box_syntax)] #![feature(conservative_impl_trait)] +#![feature(match_default_bindings)] #![feature(never_type)] #![feature(quote)] #![feature(rustc_diagnostic_macros)] diff --git a/src/test/compile-fail/closure-expected-type/README.md b/src/test/compile-fail/closure-expected-type/README.md new file mode 100644 index 00000000000..9995b00a9a7 --- /dev/null +++ b/src/test/compile-fail/closure-expected-type/README.md @@ -0,0 +1 @@ +See `src/test/run-pass/closure-expected-type`. diff --git a/src/test/compile-fail/closure-expected-type/expect-fn-supply-fn-multiple.rs b/src/test/compile-fail/closure-expected-type/expect-fn-supply-fn-multiple.rs new file mode 100644 index 00000000000..f1b198a0591 --- /dev/null +++ b/src/test/compile-fail/closure-expected-type/expect-fn-supply-fn-multiple.rs @@ -0,0 +1,49 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// must-compile-successfully + +#![feature(underscore_lifetimes)] +#![allow(warnings)] + +type Different<'a, 'b> = &'a mut (&'a (), &'b ()); +type Same<'a> = Different<'a, 'a>; + +fn with_closure_expecting_different(_: F) + where F: for<'a, 'b> FnOnce(Different<'a, 'b>) +{ +} + +fn with_closure_expecting_different_anon(_: F) + where F: FnOnce(Different<'_, '_>) +{ +} + +fn supplying_nothing_expecting_anon() { + with_closure_expecting_different_anon(|x: Different| { + }) +} + +fn supplying_nothing_expecting_named() { + with_closure_expecting_different(|x: Different| { + }) +} + +fn supplying_underscore_expecting_anon() { + with_closure_expecting_different_anon(|x: Different<'_, '_>| { + }) +} + +fn supplying_underscore_expecting_named() { + with_closure_expecting_different(|x: Different<'_, '_>| { + }) +} + +fn main() { } diff --git a/src/test/compile-fail/closure-expected-type/expect-fn-supply-fn.rs b/src/test/compile-fail/closure-expected-type/expect-fn-supply-fn.rs new file mode 100644 index 00000000000..3f129614ea0 --- /dev/null +++ b/src/test/compile-fail/closure-expected-type/expect-fn-supply-fn.rs @@ -0,0 +1,70 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(underscore_lifetimes)] + +fn with_closure_expecting_fn_with_free_region(_: F) + where F: for<'a> FnOnce(fn(&'a u32), &i32) +{ +} + +fn with_closure_expecting_fn_with_bound_region(_: 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 mismatched types +} + +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 mismatched types +} + +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 mismatched types +} + +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() { } diff --git a/src/test/compile-fail/closure-expected-type/expect-infer-var-appearing-twice.rs b/src/test/compile-fail/closure-expected-type/expect-infer-var-appearing-twice.rs new file mode 100644 index 00000000000..4ccd1c3b4f1 --- /dev/null +++ b/src/test/compile-fail/closure-expected-type/expect-infer-var-appearing-twice.rs @@ -0,0 +1,35 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn with_closure(_: F) + where F: FnOnce(A, A) +{ +} + +fn a() { + with_closure(|x: u32, y| { + // We deduce type of `y` from `x`. + }); +} + +fn b() { + // Here we take the supplied types, resulting in an error later on. + with_closure(|x: u32, y: i32| { + //~^ ERROR mismatched types + }); +} + +fn c() { + with_closure(|x, y: i32| { + // We deduce type of `x` from `y`. + }); +} + +fn main() { } diff --git a/src/test/compile-fail/closure-expected-type/expect-infer-var-supply-ty-with-bound-region.rs b/src/test/compile-fail/closure-expected-type/expect-infer-var-supply-ty-with-bound-region.rs new file mode 100644 index 00000000000..f8cb643c8d6 --- /dev/null +++ b/src/test/compile-fail/closure-expected-type/expect-infer-var-supply-ty-with-bound-region.rs @@ -0,0 +1,29 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// must-compile-successfully + +fn with_closure(_: F) + where F: FnOnce(A, &u32) +{ +} + +fn foo() { + // This version works; we infer `A` to be `u32`, and take the type + // of `y` to be `&u32`. + with_closure(|x: u32, y| {}); +} + +fn bar() { + // This version also works. + with_closure(|x: &u32, y| {}); +} + +fn main() { } diff --git a/src/test/compile-fail/closure-expected-type/expect-infer-var-supply-ty-with-free-region.rs b/src/test/compile-fail/closure-expected-type/expect-infer-var-supply-ty-with-free-region.rs new file mode 100644 index 00000000000..d3c111c5daf --- /dev/null +++ b/src/test/compile-fail/closure-expected-type/expect-infer-var-supply-ty-with-free-region.rs @@ -0,0 +1,29 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// must-compile-successfully + +fn with_closure(_: F) + where F: FnOnce(A, &u32) +{ +} + +fn foo() { + // This version works; we infer `A` to be `u32`, and take the type + // of `y` to be `&u32`. + with_closure(|x: u32, y| {}); +} + +fn bar<'x>(x: &'x u32) { + // Same. + with_closure(|x: &'x u32, y| {}); +} + +fn main() { } diff --git a/src/test/compile-fail/closure-expected-type/expect-region-supply-region.rs b/src/test/compile-fail/closure-expected-type/expect-region-supply-region.rs new file mode 100644 index 00000000000..9da12dc901f --- /dev/null +++ b/src/test/compile-fail/closure-expected-type/expect-region-supply-region.rs @@ -0,0 +1,80 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![allow(warnings)] + +fn closure_expecting_bound(_: F) + where F: FnOnce(&u32) +{ +} + +fn closure_expecting_free<'a, F>(_: F) + where F: FnOnce(&'a u32) +{ +} + +fn expect_bound_supply_nothing() { + // Because `x` is inferred to have a bound region, we cannot allow + // it to escape into `f`: + let mut f: Option<&u32> = None; + closure_expecting_bound(|x| { + f = Some(x); //~ ERROR E0495 + }); +} + +fn expect_bound_supply_bound() { + // Because `x` is inferred to have a bound region, we cannot allow + // it to escape into `f`, even with an explicit type annotation on + // closure: + let mut f: Option<&u32> = None; + closure_expecting_bound(|x: &u32| { + f = Some(x); //~ ERROR E0495 + }); +} + +fn expect_bound_supply_named<'x>() { + let mut f: Option<&u32> = None; + + // Here we give a type annotation that `x` should be free. We get + // an error because of that. + closure_expecting_bound(|x: &'x u32| { + //~^ ERROR mismatched types + //~| ERROR mismatched types + + // And we still cannot let `x` escape into `f`. + f = Some(x); + //~^ ERROR cannot infer + }); +} + +fn expect_free_supply_nothing() { + let mut f: Option<&u32> = None; + closure_expecting_free(|x| f = Some(x)); // OK +} + +fn expect_free_supply_bound() { + let mut f: Option<&u32> = None; + + // Here, even though the annotation `&u32` could be seen as being + // bound in the closure, we permit it to be defined as a free + // region (which is inferred to something in the fn body). + closure_expecting_free(|x: &u32| f = Some(x)); // OK +} + +fn expect_free_supply_named<'x>() { + let mut f: Option<&u32> = None; + + // Here, even though the annotation `&u32` could be seen as being + // bound in the closure, we permit it to be defined as a free + // region (which is inferred to something in the fn body). + closure_expecting_free(|x: &'x u32| f = Some(x)); // OK +} + +fn main() { } diff --git a/src/test/compile-fail/closure-expected-type/expect-two-infer-vars-supply-ty-with-bound-region.rs b/src/test/compile-fail/closure-expected-type/expect-two-infer-vars-supply-ty-with-bound-region.rs new file mode 100644 index 00000000000..377eaadbd6a --- /dev/null +++ b/src/test/compile-fail/closure-expected-type/expect-two-infer-vars-supply-ty-with-bound-region.rs @@ -0,0 +1,29 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn with_closure(_: F) + where F: FnOnce(A, B) +{ +} + +fn a() { + // Type of `y` is unconstrained. + with_closure(|x: u32, y| {}); //~ ERROR E0282 +} + +fn b() { + with_closure(|x: u32, y: u32| {}); // OK +} + +fn c() { + with_closure(|x: u32, y: u32| {}); // OK +} + +fn main() { } diff --git a/src/test/mir-opt/validate_1.rs b/src/test/mir-opt/validate_1.rs index 53454c0cc9a..a97ce4e8cbe 100644 --- a/src/test/mir-opt/validate_1.rs +++ b/src/test/mir-opt/validate_1.rs @@ -62,7 +62,7 @@ fn main() { // fn main::{{closure}}(_1: &ReErased [closure@NodeId(50)], _2: &ReErased mut i32) -> i32 { // ... // bb0: { -// Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:11) => validate_1[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(50)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:11) => validate_1[317d]::main[0]::{{closure}}[0] }, BrAnon(1)) mut i32]); +// Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:11) => validate_1[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(50)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:11) => validate_1[317d]::main[0]::{{closure}}[0] }, BrAnon(0)) mut i32]); // StorageLive(_3); // Validate(Suspend(ReScope(Remainder(BlockRemainder { block: ItemLocalId(22), first_statement_index: 0 }))), [(*_2): i32]); // _3 = &ReErased (*_2); diff --git a/src/test/mir-opt/validate_4.rs b/src/test/mir-opt/validate_4.rs index 042edca82a6..3585ac0b8be 100644 --- a/src/test/mir-opt/validate_4.rs +++ b/src/test/mir-opt/validate_4.rs @@ -78,8 +78,8 @@ fn main() { // fn main::{{closure}}(_1: &ReErased [closure@NodeId(60)], _2: &ReErased mut i32) -> bool { // ... // bb0: { -// Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(60)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrAnon(1)) mut i32]); -// Validate(Release, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(60)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrAnon(1)) mut i32]); +// Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(60)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrAnon(0)) mut i32]); +// Validate(Release, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(60)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrAnon(0)) mut i32]); // StorageLive(_3); // ... // _0 = const write_42(_3) -> bb1; diff --git a/src/test/mir-opt/validate_5.rs b/src/test/mir-opt/validate_5.rs index fc849c5aee3..ae09d72942e 100644 --- a/src/test/mir-opt/validate_5.rs +++ b/src/test/mir-opt/validate_5.rs @@ -49,7 +49,7 @@ fn main() { // fn main::{{closure}}(_1: &ReErased [closure@NodeId(46)], _2: &ReErased mut i32) -> bool { // ... // bb0: { -// Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:9) => validate_5[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(46)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:9) => validate_5[317d]::main[0]::{{closure}}[0] }, BrAnon(1)) mut i32]); +// Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:9) => validate_5[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(46)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:9) => validate_5[317d]::main[0]::{{closure}}[0] }, BrAnon(0)) mut i32]); // StorageLive(_3); // StorageLive(_4); // Validate(Suspend(ReScope(Node(ItemLocalId(9)))), [(*_2): i32]); diff --git a/src/test/run-pass/closure-expected-type/README.md b/src/test/run-pass/closure-expected-type/README.md new file mode 100644 index 00000000000..fd493e1ff37 --- /dev/null +++ b/src/test/run-pass/closure-expected-type/README.md @@ -0,0 +1,8 @@ +Some tests targeted at how we deduce the types of closure arguments. +This process is a result of some heuristics aimed at combining the +*expected type* we have with the *actual types* that we get from +inputs. This investigation was kicked off by #38714, which revealed +some pretty deep flaws in the ad-hoc way that we were doing things +before. + +See also `src/test/compile-fail/closure-expected-type`. diff --git a/src/test/run-pass/closure-expected-type/expect-infer-supply-two-infers.rs b/src/test/run-pass/closure-expected-type/expect-infer-supply-two-infers.rs new file mode 100644 index 00000000000..8a90a491f7e --- /dev/null +++ b/src/test/run-pass/closure-expected-type/expect-infer-supply-two-infers.rs @@ -0,0 +1,26 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn with_closure(_: F) + where F: FnOnce(Vec, A) +{ +} + +fn expect_free_supply_free<'x>(x: &'x u32) { + with_closure(|mut x: Vec<_>, y| { + // Shows that the call to `x.push()` is influencing type of `y`... + x.push(22_u32); + + // ...since we now know the type of `y` and can resolve the method call. + y.wrapping_add(1); + }); +} + +fn main() { } diff --git a/src/test/run-pass/closure-expected-type/issue-38714.rs b/src/test/run-pass/closure-expected-type/issue-38714.rs new file mode 100644 index 00000000000..a1d512105c9 --- /dev/null +++ b/src/test/run-pass/closure-expected-type/issue-38714.rs @@ -0,0 +1,26 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +struct UsizeRef<'a> { + a: &'a usize +} + +type RefTo = Box Fn(&'r Vec) -> UsizeRef<'r>>; + +fn ref_to<'a>(vec: &'a Vec) -> UsizeRef<'a> { + UsizeRef{ a: &vec[0]} +} + +fn main() { + // Regression test: this was causing ICEs; it should compile. + let a: RefTo = Box::new(|vec: &Vec| { + UsizeRef{ a: &vec[0] } + }); +} diff --git a/src/test/run-pass/closure-expected-type/supply-just-return-type.rs b/src/test/run-pass/closure-expected-type/supply-just-return-type.rs new file mode 100644 index 00000000000..0b930b338fd --- /dev/null +++ b/src/test/run-pass/closure-expected-type/supply-just-return-type.rs @@ -0,0 +1,35 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn with_closure(f: F) -> Result + where F: FnOnce(&char) -> Result, +{ + f(&'a') +} + +fn main() { + // Test that supplying the `-> Result` manually here + // (which is needed to constrain `R`) still allows us to figure + // out that the type of `x` is `&'a char` where `'a` is bound in + // the closure (if we didn't, we'd get a type-error because + // `with_closure` requires a bound region). + // + // This pattern was found in the wild. + let z = with_closure(|x| -> Result { Ok(*x) }); + assert_eq!(z.unwrap(), 'a'); + + // It also works with `_`: + let z = with_closure(|x: _| -> Result { Ok(*x) }); + assert_eq!(z.unwrap(), 'a'); + + // It also works with `&_`: + let z = with_closure(|x: &_| -> Result { Ok(*x) }); + assert_eq!(z.unwrap(), 'a'); +} diff --git a/src/test/run-pass/closure-expected-type/supply-nothing.rs b/src/test/run-pass/closure-expected-type/supply-nothing.rs new file mode 100644 index 00000000000..15d8b393c15 --- /dev/null +++ b/src/test/run-pass/closure-expected-type/supply-nothing.rs @@ -0,0 +1,20 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn with_closure(f: F) -> u32 + where F: FnOnce(&u32, &u32) -> u32 +{ + f(&22, &44) +} + +fn main() { + let z = with_closure(|x, y| x + y).wrapping_add(1); + assert_eq!(z, 22 + 44 + 1); +}