From b4f5ddba67d2fa81f90bfaadbb8ec83321dd3dcc Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Sat, 2 Jan 2016 04:57:55 -0500 Subject: [PATCH 1/6] Make coherence more tolerant of error types. Fixes #29857. Fixes #30589. --- src/librustc/middle/traits/coherence.rs | 5 +++- src/librustc_typeck/coherence/mod.rs | 12 ++++++++ .../coherence-projection-conflict-orphan.rs | 28 ++++++++++++++++++ .../coherence-projection-conflict.rs | 27 +++++++++++++++++ .../coherence-projection-ok-orphan.rs | 29 +++++++++++++++++++ .../compile-fail/coherence-projection-ok.rs | 28 ++++++++++++++++++ src/test/compile-fail/issue-29857.rs | 27 +++++++++++++++++ src/test/compile-fail/issue-30589.rs | 19 ++++++++++++ 8 files changed, 174 insertions(+), 1 deletion(-) create mode 100644 src/test/compile-fail/coherence-projection-conflict-orphan.rs create mode 100644 src/test/compile-fail/coherence-projection-conflict.rs create mode 100644 src/test/compile-fail/coherence-projection-ok-orphan.rs create mode 100644 src/test/compile-fail/coherence-projection-ok.rs create mode 100644 src/test/compile-fail/issue-29857.rs create mode 100644 src/test/compile-fail/issue-30589.rs diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index cb166fbff0585..62a769fbff824 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -330,8 +330,11 @@ fn ty_is_local_constructor<'tcx>(tcx: &ty::ctxt<'tcx>, tt.principal_def_id().is_local() } - ty::TyClosure(..) | ty::TyError => { + true + } + + ty::TyClosure(..) => { tcx.sess.bug( &format!("ty_is_local invoked on unexpected type: {:?}", ty)) diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 2c8fedb46a7b7..7465ff526b6de 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -149,11 +149,23 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { trait_ref, item.name); + // Skip impls where one of the self type is an error type. + // This occurs with e.g. resolve failures (#30589). + if trait_ref.references_error() { + return; + } + enforce_trait_manually_implementable(self.crate_context.tcx, item.span, trait_ref.def_id); self.add_trait_impl(trait_ref, impl_did); } else { + // Skip inherent impls where the self type is an error + // type. This occurs with e.g. resolve failures (#30589). + if self_type.ty.references_error() { + return; + } + // Add the implementation to the mapping from implementation to base // type def ID, if there is a base type for this implementation and // the implementation does not have any associated traits. diff --git a/src/test/compile-fail/coherence-projection-conflict-orphan.rs b/src/test/compile-fail/coherence-projection-conflict-orphan.rs new file mode 100644 index 0000000000000..3de7945439838 --- /dev/null +++ b/src/test/compile-fail/coherence-projection-conflict-orphan.rs @@ -0,0 +1,28 @@ +// 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(rustc_attrs)] + +// Here we expect a coherence conflict because, even though `i32` does +// not implement `Iterator`, we cannot rely on that negative reasoning +// due to the orphan rules. Therefore, `A::Item` may yet turn out to +// be `i32`. + +pub trait Foo

{} + +pub trait Bar { + type Output: 'static; +} + +impl Foo for i32 { } //~ ERROR E0119 + +impl Foo for A { } + +fn main() {} diff --git a/src/test/compile-fail/coherence-projection-conflict.rs b/src/test/compile-fail/coherence-projection-conflict.rs new file mode 100644 index 0000000000000..2236e71b53fff --- /dev/null +++ b/src/test/compile-fail/coherence-projection-conflict.rs @@ -0,0 +1,27 @@ +// 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. + +use std::marker::PhantomData; + +pub trait Foo

{} + +pub trait Bar { + type Output: 'static; +} + +impl Foo for i32 { } //~ ERROR E0119 + +impl Foo for A { } + +impl Bar for i32 { + type Output = i32; +} + +fn main() {} diff --git a/src/test/compile-fail/coherence-projection-ok-orphan.rs b/src/test/compile-fail/coherence-projection-ok-orphan.rs new file mode 100644 index 0000000000000..a52af0873a823 --- /dev/null +++ b/src/test/compile-fail/coherence-projection-ok-orphan.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. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +// Here we do not get a coherence conflict because `Baz: Iterator` +// does not hold and (due to the orphan rules), we can rely on that. + +pub trait Foo

{} + +pub trait Bar { + type Output: 'static; +} + +struct Baz; +impl Foo for Baz { } + +impl Foo for A { } + +#[rustc_error] +fn main() {} //~ ERROR compilation successful diff --git a/src/test/compile-fail/coherence-projection-ok.rs b/src/test/compile-fail/coherence-projection-ok.rs new file mode 100644 index 0000000000000..af88f3744eaeb --- /dev/null +++ b/src/test/compile-fail/coherence-projection-ok.rs @@ -0,0 +1,28 @@ +// 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(rustc_attrs)] + +pub trait Foo

{} + +pub trait Bar { + type Output: 'static; +} + +impl Foo for i32 { } + +impl Foo for A { } + +impl Bar for i32 { + type Output = u32; +} + +#[rustc_error] +fn main() {} //~ ERROR compilation successful diff --git a/src/test/compile-fail/issue-29857.rs b/src/test/compile-fail/issue-29857.rs new file mode 100644 index 0000000000000..b46246cd2164b --- /dev/null +++ b/src/test/compile-fail/issue-29857.rs @@ -0,0 +1,27 @@ +// 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. + +use std::marker::PhantomData; + +pub trait Foo

{} + +impl > Foo

for Option {} //~ ERROR E0119 + +pub struct Qux (PhantomData<*mut T>); + +impl Foo<*mut T> for Option> {} + +pub trait Bar { + type Output: 'static; +} + +impl> Foo<*mut T> for W {} + +fn main() {} diff --git a/src/test/compile-fail/issue-30589.rs b/src/test/compile-fail/issue-30589.rs new file mode 100644 index 0000000000000..32765d5acb4fe --- /dev/null +++ b/src/test/compile-fail/issue-30589.rs @@ -0,0 +1,19 @@ +// 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. + +use std::fmt; + +impl fmt::Display for DecoderError { //~ ERROR E0412 + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "Missing data: {}", self.0) + } +} +fn main() { +} From 64b720229c1fc819db00a45d43a3a0815a3b5809 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 7 Jan 2016 16:48:48 -0500 Subject: [PATCH 2/6] Remove ErrorCandidate in favor of just generating an ambiguous result --- src/librustc/middle/traits/coherence.rs | 4 ++-- src/librustc/middle/traits/select.rs | 18 +++++++++--------- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index 62a769fbff824..0f95aa74b6fd7 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -63,9 +63,9 @@ fn overlap<'cx, 'tcx>(selcx: &mut SelectionContext<'cx, 'tcx>, b_def_id, util::fresh_type_vars_for_impl); - debug!("overlap: a_trait_ref={:?}", a_trait_ref); + debug!("overlap: a_trait_ref={:?} a_obligations={:?}", a_trait_ref, a_obligations); - debug!("overlap: b_trait_ref={:?}", b_trait_ref); + debug!("overlap: b_trait_ref={:?} b_obligations={:?}", b_trait_ref, b_obligations); // Do `a` and `b` unify? If not, no overlap. if let Err(_) = infer::mk_eq_trait_refs(selcx.infcx(), diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index f544f8ce36234..f6d0da904a40f 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -210,8 +210,6 @@ enum SelectionCandidate<'tcx> { BuiltinObjectCandidate, BuiltinUnsizeCandidate, - - ErrorCandidate, } struct SelectionCandidateSet<'tcx> { @@ -753,8 +751,15 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { stack: &TraitObligationStack<'o, 'tcx>) -> SelectionResult<'tcx, SelectionCandidate<'tcx>> { - if stack.obligation.predicate.0.self_ty().references_error() { - return Ok(Some(ErrorCandidate)); + if stack.obligation.predicate.references_error() { + // If we encounter a `TyError`, we generally prefer the + // most "optimistic" result in response -- that is, the + // one least likely to report downstream errors. But + // because this routine is shared by coherence and by + // trait selection, there isn't an obvious "right" choice + // here in that respect, so we opt to just return + // ambiguity and let the upstream clients sort it out. + return Ok(None); } if !self.is_knowable(stack) { @@ -1587,7 +1592,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { true }, &ParamCandidate(..) => false, - &ErrorCandidate => false // propagate errors }, _ => false } @@ -1998,10 +2002,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { try!(self.confirm_builtin_candidate(obligation, builtin_bound)))) } - ErrorCandidate => { - Ok(VtableBuiltin(VtableBuiltinData { nested: vec![] })) - } - ParamCandidate(param) => { let obligations = self.confirm_param_candidate(obligation, param); Ok(VtableParam(obligations)) From 77756cb12ae718cd3b20c0da2b3b89c881910b1d Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 7 Jan 2016 13:51:16 -0500 Subject: [PATCH 3/6] Change error scheme so that if projection fails we generate `A::B` instead of `TyError` --- src/librustc/middle/traits/project.rs | 25 +++++++++++++++---- src/librustc_typeck/check/mod.rs | 3 +++ .../coherence-projection-conflict-ty-param.rs | 22 ++++++++++++++++ .../compile-fail/const-eval-overflow-4b.rs | 2 +- src/test/compile-fail/issue-19692.rs | 2 +- src/test/compile-fail/issue-21950.rs | 2 +- src/test/compile-fail/issue-23966.rs | 4 ++- src/test/compile-fail/issue-24352.rs | 2 +- src/test/compile-fail/issue-29857.rs | 8 ++++-- src/test/compile-fail/issue-3973.rs | 1 - 10 files changed, 58 insertions(+), 13 deletions(-) create mode 100644 src/test/compile-fail/coherence-projection-conflict-ty-param.rs diff --git a/src/librustc/middle/traits/project.rs b/src/librustc/middle/traits/project.rs index ad3524661d326..e9d7b330d07ac 100644 --- a/src/librustc/middle/traits/project.rs +++ b/src/librustc/middle/traits/project.rs @@ -426,11 +426,25 @@ fn opt_normalize_projection_type<'a,'b,'tcx>( } } -/// in various error cases, we just set TyError and return an obligation -/// that, when fulfilled, will lead to an error. +/// If we are projecting `::Item`, but `T: Trait` does not +/// hold. In various error cases, we cannot generate a valid +/// normalized projection. Therefore, we create an inference variable +/// return an associated obligation that, when fulfilled, will lead to +/// an error. /// -/// FIXME: the TyError created here can enter the obligation we create, -/// leading to error messages involving TyError. +/// Note that we used to return `TyError` here, but that was quite +/// dubious -- the premise was that an error would *eventually* be +/// reported, when the obligation was processed. But in general once +/// you see a `TyError` you are supposed to be able to assume that an +/// error *has been* reported, so that you can take whatever heuristic +/// paths you want to take. To make things worse, it was possible for +/// cycles to arise, where you basically had a setup like ` +/// as Trait>::Foo == $0`. Here, normalizing ` as +/// Trait>::Foo> to `[type error]` would lead to an obligation of +/// ` as Trait>::Foo`. We are supposed to report +/// an error for this obligation, but we legitimately should not, +/// because it contains `[type error]`. Yuck! (See issue #29857 for +/// one case where this arose.) fn normalize_to_error<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>, projection_ty: ty::ProjectionTy<'tcx>, cause: ObligationCause<'tcx>, @@ -441,8 +455,9 @@ fn normalize_to_error<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>, let trait_obligation = Obligation { cause: cause, recursion_depth: depth, predicate: trait_ref.to_predicate() }; + let new_value = selcx.infcx().next_ty_var(); Normalized { - value: selcx.tcx().types.err, + value: new_value, obligations: vec!(trait_obligation) } } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 3cf75483fea0f..dbc22bcde9ec7 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1038,6 +1038,9 @@ fn report_cast_to_unsized_type<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, t_cast: Ty<'tcx>, t_expr: Ty<'tcx>, id: ast::NodeId) { + if t_cast.references_error() || t_expr.references_error() { + return; + } let tstr = fcx.infcx().ty_to_string(t_cast); let mut err = fcx.type_error_struct(span, |actual| { format!("cast to unsized type: `{}` as `{}`", actual, tstr) diff --git a/src/test/compile-fail/coherence-projection-conflict-ty-param.rs b/src/test/compile-fail/coherence-projection-conflict-ty-param.rs new file mode 100644 index 0000000000000..6880f3e9a3cc9 --- /dev/null +++ b/src/test/compile-fail/coherence-projection-conflict-ty-param.rs @@ -0,0 +1,22 @@ +// 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. + +// Coherence error results because we do not know whether `T: Foo

` or not +// for the second impl. + +use std::marker::PhantomData; + +pub trait Foo

{} + +impl > Foo

for Option {} //~ ERROR E0119 + +impl Foo for Option { } + +fn main() {} diff --git a/src/test/compile-fail/const-eval-overflow-4b.rs b/src/test/compile-fail/const-eval-overflow-4b.rs index a8f47ab92e529..253285d3919c2 100644 --- a/src/test/compile-fail/const-eval-overflow-4b.rs +++ b/src/test/compile-fail/const-eval-overflow-4b.rs @@ -22,7 +22,7 @@ use std::{u8, u16, u32, u64, usize}; const A_I8_T : [u32; (i8::MAX as i8 + 1u8) as usize] //~^ ERROR mismatched types - //~| the trait `core::ops::Add` is not implemented for the type `i8` + //~| ERROR the trait `core::ops::Add` is not implemented for the type `i8` = [0; (i8::MAX as usize) + 1]; fn main() { diff --git a/src/test/compile-fail/issue-19692.rs b/src/test/compile-fail/issue-19692.rs index 88ae0f835d0d7..ca1715445e526 100644 --- a/src/test/compile-fail/issue-19692.rs +++ b/src/test/compile-fail/issue-19692.rs @@ -12,7 +12,7 @@ struct Homura; fn akemi(homura: Homura) { let Some(ref madoka) = Some(homura.kaname()); //~ ERROR no method named `kaname` found - madoka.clone(); //~ ERROR the type of this value must be known in this context + madoka.clone(); } fn main() { } diff --git a/src/test/compile-fail/issue-21950.rs b/src/test/compile-fail/issue-21950.rs index 900ad5ce812e3..ef6ce5c995bf3 100644 --- a/src/test/compile-fail/issue-21950.rs +++ b/src/test/compile-fail/issue-21950.rs @@ -16,5 +16,5 @@ fn main() { let x = &10 as &Add; //~^ ERROR the type parameter `RHS` must be explicitly specified in an object type because its default value `Self` references the type `Self` - //~^^ ERROR the value of the associated type `Output` (from the trait `core::ops::Add`) must be specified + //~| ERROR the value of the associated type `Output` (from the trait `core::ops::Add`) must be specified } diff --git a/src/test/compile-fail/issue-23966.rs b/src/test/compile-fail/issue-23966.rs index d7f909e4ebcf6..7f9c7a292f2be 100644 --- a/src/test/compile-fail/issue-23966.rs +++ b/src/test/compile-fail/issue-23966.rs @@ -9,5 +9,7 @@ // except according to those terms. fn main() { - "".chars().fold(|_, _| (), ()); //~ ERROR is not implemented for the type `()` + "".chars().fold(|_, _| (), ()); + //~^ ERROR E0277 + //~| ERROR E0277 } diff --git a/src/test/compile-fail/issue-24352.rs b/src/test/compile-fail/issue-24352.rs index 9936f67b3af3c..4b0773140566c 100644 --- a/src/test/compile-fail/issue-24352.rs +++ b/src/test/compile-fail/issue-24352.rs @@ -10,5 +10,5 @@ fn main() { 1.0f64 - 1.0; - 1.0f64 - 1 //~ ERROR: is not implemented + 1.0f64 - 1 //~ ERROR E0277 } diff --git a/src/test/compile-fail/issue-29857.rs b/src/test/compile-fail/issue-29857.rs index b46246cd2164b..661579f52b684 100644 --- a/src/test/compile-fail/issue-29857.rs +++ b/src/test/compile-fail/issue-29857.rs @@ -8,11 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. + +#![feature(rustc_attrs)] + use std::marker::PhantomData; pub trait Foo

{} -impl > Foo

for Option {} //~ ERROR E0119 +impl > Foo

for Option {} pub struct Qux (PhantomData<*mut T>); @@ -24,4 +27,5 @@ pub trait Bar { impl> Foo<*mut T> for W {} -fn main() {} +#[rustc_error] +fn main() {} //~ ERROR compilation successful diff --git a/src/test/compile-fail/issue-3973.rs b/src/test/compile-fail/issue-3973.rs index 1fda423e9ee8d..92456760b0508 100644 --- a/src/test/compile-fail/issue-3973.rs +++ b/src/test/compile-fail/issue-3973.rs @@ -32,5 +32,4 @@ fn main() { let p = Point::new(0.0, 0.0); //~^ ERROR no associated item named `new` found for type `Point` in the current scope println!("{}", p.to_string()); - //~^ ERROR the type of this value must be known in this context } From a3cbfa58be12a3ae0c4efd71c3e8c39554924e08 Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Wed, 25 Nov 2015 18:17:16 +0200 Subject: [PATCH 4/6] improve cast handling - this fixes test failures the problem is that now "type_is_known_to_be_sized" now returns false when called on a type with ty_err inside - this prevents spurious errors (we may want to move the check to check::cast anyway - see #12894). --- src/librustc_typeck/check/mod.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index dbc22bcde9ec7..e644178ddd62f 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -3514,9 +3514,10 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let t_cast = structurally_resolved_type(fcx, expr.span, t_cast); check_expr_with_expectation(fcx, e, ExpectCastableToType(t_cast)); let t_expr = fcx.expr_ty(e); + let t_cast = fcx.infcx().resolve_type_vars_if_possible(&t_cast); // Eagerly check for some obvious errors. - if t_expr.references_error() { + if t_expr.references_error() || t_cast.references_error() { fcx.write_error(id); } else if !fcx.type_is_known_to_be_sized(t_cast, expr.span) { report_cast_to_unsized_type(fcx, expr.span, t.span, e.span, t_cast, t_expr, id); From 83710b44716cb078fde8992acc4f28839eefbe51 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 8 Jan 2016 20:16:30 -0500 Subject: [PATCH 5/6] permit coercions if `[error]` is found in either type --- src/librustc_typeck/check/coercion.rs | 55 +++++++++++++-------------- src/test/compile-fail/issue-19692.rs | 2 +- src/test/compile-fail/issue-3973.rs | 2 +- 3 files changed, 29 insertions(+), 30 deletions(-) diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index 85f0aa3bbd3c3..f91f13f586c41 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -68,7 +68,7 @@ use middle::traits::{predicate_for_trait_def, report_selection_error}; use middle::ty::adjustment::{AutoAdjustment, AutoDerefRef, AdjustDerefRef}; use middle::ty::adjustment::{AutoPtr, AutoUnsafe, AdjustReifyFnPointer}; use middle::ty::adjustment::{AdjustUnsafeFnPointer}; -use middle::ty::{self, LvaluePreference, TypeAndMut, Ty}; +use middle::ty::{self, LvaluePreference, TypeAndMut, Ty, HasTypeFlags}; use middle::ty::error::TypeError; use middle::ty::relate::RelateResult; use util::common::indent; @@ -110,10 +110,15 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { a, b); + let a = self.fcx.infcx().shallow_resolve(a); + + // Just ignore error types. + if a.references_error() || b.references_error() { + return Ok(None); + } + // Consider coercing the subtype to a DST - let unsize = self.unpack_actual_value(a, |a| { - self.coerce_unsized(a, b) - }); + let unsize = self.coerce_unsized(a, b); if unsize.is_ok() { return unsize; } @@ -124,39 +129,33 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { // See above for details. match b.sty { ty::TyRawPtr(mt_b) => { - return self.unpack_actual_value(a, |a| { - self.coerce_unsafe_ptr(a, b, mt_b.mutbl) - }); + return self.coerce_unsafe_ptr(a, b, mt_b.mutbl); } ty::TyRef(_, mt_b) => { - return self.unpack_actual_value(a, |a| { - self.coerce_borrowed_pointer(expr_a, a, b, mt_b.mutbl) - }); + return self.coerce_borrowed_pointer(expr_a, a, b, mt_b.mutbl); } _ => {} } - self.unpack_actual_value(a, |a| { - match a.sty { - ty::TyBareFn(Some(_), a_f) => { - // Function items are coercible to any closure - // type; function pointers are not (that would - // require double indirection). - self.coerce_from_fn_item(a, a_f, b) - } - ty::TyBareFn(None, a_f) => { - // We permit coercion of fn pointers to drop the - // unsafe qualifier. - self.coerce_from_fn_pointer(a, a_f, b) - } - _ => { - // Otherwise, just use subtyping rules. - self.subtype(a, b) - } + match a.sty { + ty::TyBareFn(Some(_), a_f) => { + // Function items are coercible to any closure + // type; function pointers are not (that would + // require double indirection). + self.coerce_from_fn_item(a, a_f, b) } - }) + ty::TyBareFn(None, a_f) => { + // We permit coercion of fn pointers to drop the + // unsafe qualifier. + self.coerce_from_fn_pointer(a, a_f, b) + } + _ => { + // Otherwise, just use subtyping rules. + self.subtype(a, b) + } + } } /// Reborrows `&mut A` to `&mut B` and `&(mut) A` to `&B`. diff --git a/src/test/compile-fail/issue-19692.rs b/src/test/compile-fail/issue-19692.rs index ca1715445e526..53ad241687894 100644 --- a/src/test/compile-fail/issue-19692.rs +++ b/src/test/compile-fail/issue-19692.rs @@ -12,7 +12,7 @@ struct Homura; fn akemi(homura: Homura) { let Some(ref madoka) = Some(homura.kaname()); //~ ERROR no method named `kaname` found - madoka.clone(); + madoka.clone(); //~ ERROR the type of this value must be known } fn main() { } diff --git a/src/test/compile-fail/issue-3973.rs b/src/test/compile-fail/issue-3973.rs index 92456760b0508..54eb2a9082955 100644 --- a/src/test/compile-fail/issue-3973.rs +++ b/src/test/compile-fail/issue-3973.rs @@ -31,5 +31,5 @@ impl ToString_ for Point { fn main() { let p = Point::new(0.0, 0.0); //~^ ERROR no associated item named `new` found for type `Point` in the current scope - println!("{}", p.to_string()); + println!("{}", p.to_string()); //~ ERROR type of this value must be known } From b0f6a47a0f05af991d8b0e40b29ac8290ac845f5 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 8 Jan 2016 21:00:24 -0500 Subject: [PATCH 6/6] Minor rebase corrections --- src/librustc_typeck/check/coercion.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index f91f13f586c41..8f64e85de4b0f 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -68,7 +68,8 @@ use middle::traits::{predicate_for_trait_def, report_selection_error}; use middle::ty::adjustment::{AutoAdjustment, AutoDerefRef, AdjustDerefRef}; use middle::ty::adjustment::{AutoPtr, AutoUnsafe, AdjustReifyFnPointer}; use middle::ty::adjustment::{AdjustUnsafeFnPointer}; -use middle::ty::{self, LvaluePreference, TypeAndMut, Ty, HasTypeFlags}; +use middle::ty::{self, LvaluePreference, TypeAndMut, Ty}; +use middle::ty::fold::TypeFoldable; use middle::ty::error::TypeError; use middle::ty::relate::RelateResult; use util::common::indent;