src/librustc_typeck/check/compare_method.rs

   1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use middle::free_region::FreeRegionMap;
  12 use rustc::infer::{self, InferOk, TypeOrigin};
  13 use rustc::ty;
  14 use rustc::traits::{self, ProjectionMode};
  15 use rustc::ty::error::ExpectedFound;
  16 use rustc::ty::subst::{self, Subst, Substs, VecPerParamSpace};
  17
  18 use syntax::ast;
  19 use syntax_pos::Span;
  20
  21 use CrateCtxt;
  22 use super::assoc;
  23
  24 /// Checks that a method from an impl conforms to the signature of
  25 /// the same method as declared in the trait.
  26 ///
  27 /// # Parameters
  28 ///
  29 /// - impl_m: type of the method we are checking
  30 /// - impl_m_span: span to use for reporting errors
  31 /// - impl_m_body_id: id of the method body
  32 /// - trait_m: the method in the trait
  33 /// - impl_trait_ref: the TraitRef corresponding to the trait implementation
  34
  35 pub fn compare_impl_method<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
  36                                      impl_m: &ty::Method<'tcx>,
  37                                      impl_m_span: Span,
  38                                      impl_m_body_id: ast::NodeId,
  39                                      trait_m: &ty::Method<'tcx>,
  40                                      impl_trait_ref: &ty::TraitRef<'tcx>) {
  41     debug!("compare_impl_method(impl_trait_ref={:?})",
  42            impl_trait_ref);
  43
  44     debug!("compare_impl_method: impl_trait_ref (liberated) = {:?}",
  45            impl_trait_ref);
  46
  47     let tcx = ccx.tcx;
  48
  49     let trait_to_impl_substs = &impl_trait_ref.substs;
  50
  51     // Try to give more informative error messages about self typing
  52     // mismatches.  Note that any mismatch will also be detected
  53     // below, where we construct a canonical function type that
  54     // includes the self parameter as a normal parameter.  It's just
  55     // that the error messages you get out of this code are a bit more
  56     // inscrutable, particularly for cases where one method has no
  57     // self.
  58     match (&trait_m.explicit_self, &impl_m.explicit_self) {
  59         (&ty::ExplicitSelfCategory::Static,
  60          &ty::ExplicitSelfCategory::Static) => {}
  61         (&ty::ExplicitSelfCategory::Static, _) => {
  62             span_err!(tcx.sess, impl_m_span, E0185,
  63                 "method `{}` has a `{}` declaration in the impl, \
  64                         but not in the trait",
  65                         trait_m.name,
  66                         impl_m.explicit_self);
  67             return;
  68         }
  69         (_, &ty::ExplicitSelfCategory::Static) => {
  70             span_err!(tcx.sess, impl_m_span, E0186,
  71                 "method `{}` has a `{}` declaration in the trait, \
  72                         but not in the impl",
  73                         trait_m.name,
  74                         trait_m.explicit_self);
  75             return;
  76         }
  77         _ => {
  78             // Let the type checker catch other errors below
  79         }
  80     }
  81
  82     let num_impl_m_type_params = impl_m.generics.types.len(subst::FnSpace);
  83     let num_trait_m_type_params = trait_m.generics.types.len(subst::FnSpace);
  84     if num_impl_m_type_params != num_trait_m_type_params {
  85         span_err!(tcx.sess, impl_m_span, E0049,
  86             "method `{}` has {} type parameter{} \
  87              but its trait declaration has {} type parameter{}",
  88             trait_m.name,
  89             num_impl_m_type_params,
  90             if num_impl_m_type_params == 1 {""} else {"s"},
  91             num_trait_m_type_params,
  92             if num_trait_m_type_params == 1 {""} else {"s"});
  93         return;
  94     }
  95
  96     if impl_m.fty.sig.0.inputs.len() != trait_m.fty.sig.0.inputs.len() {
  97         span_err!(tcx.sess, impl_m_span, E0050,
  98             "method `{}` has {} parameter{} \
  99              but the declaration in trait `{}` has {}",
 100             trait_m.name,
 101             impl_m.fty.sig.0.inputs.len(),
 102             if impl_m.fty.sig.0.inputs.len() == 1 {""} else {"s"},
 103             tcx.item_path_str(trait_m.def_id),
 104             trait_m.fty.sig.0.inputs.len());
 105         return;
 106     }
 107
 108     // This code is best explained by example. Consider a trait:
 109     //
 110     //     trait Trait<'t,T> {
 111     //          fn method<'a,M>(t: &'t T, m: &'a M) -> Self;
 112     //     }
 113     //
 114     // And an impl:
 115     //
 116     //     impl<'i, 'j, U> Trait<'j, &'i U> for Foo {
 117     //          fn method<'b,N>(t: &'j &'i U, m: &'b N) -> Foo;
 118     //     }
 119     //
 120     // We wish to decide if those two method types are compatible.
 121     //
 122     // We start out with trait_to_impl_substs, that maps the trait
 123     // type parameters to impl type parameters. This is taken from the
 124     // impl trait reference:
 125     //
 126     //     trait_to_impl_substs = {'t => 'j, T => &'i U, Self => Foo}
 127     //
 128     // We create a mapping `dummy_substs` that maps from the impl type
 129     // parameters to fresh types and regions. For type parameters,
 130     // this is the identity transform, but we could as well use any
 131     // skolemized types. For regions, we convert from bound to free
 132     // regions (Note: but only early-bound regions, i.e., those
 133     // declared on the impl or used in type parameter bounds).
 134     //
 135     //     impl_to_skol_substs = {'i => 'i0, U => U0, N => N0 }
 136     //
 137     // Now we can apply skol_substs to the type of the impl method
 138     // to yield a new function type in terms of our fresh, skolemized
 139     // types:
 140     //
 141     //     <'b> fn(t: &'i0 U0, m: &'b) -> Foo
 142     //
 143     // We now want to extract and substitute the type of the *trait*
 144     // method and compare it. To do so, we must create a compound
 145     // substitution by combining trait_to_impl_substs and
 146     // impl_to_skol_substs, and also adding a mapping for the method
 147     // type parameters. We extend the mapping to also include
 148     // the method parameters.
 149     //
 150     //     trait_to_skol_substs = { T => &'i0 U0, Self => Foo, M => N0 }
 151     //
 152     // Applying this to the trait method type yields:
 153     //
 154     //     <'a> fn(t: &'i0 U0, m: &'a) -> Foo
 155     //
 156     // This type is also the same but the name of the bound region ('a
 157     // vs 'b).  However, the normal subtyping rules on fn types handle
 158     // this kind of equivalency just fine.
 159     //
 160     // We now use these substitutions to ensure that all declared bounds are
 161     // satisfied by the implementation's method.
 162     //
 163     // We do this by creating a parameter environment which contains a
 164     // substitution corresponding to impl_to_skol_substs. We then build
 165     // trait_to_skol_substs and use it to convert the predicates contained
 166     // in the trait_m.generics to the skolemized form.
 167     //
 168     // Finally we register each of these predicates as an obligation in
 169     // a fresh FulfillmentCtxt, and invoke select_all_or_error.
 170
 171     // Create a parameter environment that represents the implementation's
 172     // method.
 173     let impl_m_node_id = tcx.map.as_local_node_id(impl_m.def_id).unwrap();
 174     let impl_param_env = ty::ParameterEnvironment::for_item(tcx, impl_m_node_id);
 175
 176     // Create mapping from impl to skolemized.
 177     let impl_to_skol_substs = &impl_param_env.free_substs;
 178
 179     // Create mapping from trait to skolemized.
 180     let trait_to_skol_substs =
 181         trait_to_impl_substs
 182         .subst(tcx, impl_to_skol_substs).clone()
 183         .with_method(impl_to_skol_substs.types.get_slice(subst::FnSpace).to_vec(),
 184                      impl_to_skol_substs.regions.get_slice(subst::FnSpace).to_vec());
 185     debug!("compare_impl_method: trait_to_skol_substs={:?}",
 186            trait_to_skol_substs);
 187
 188     // Check region bounds. FIXME(@jroesch) refactor this away when removing
 189     // ParamBounds.
 190     if !check_region_bounds_on_impl_method(ccx,
 191                                            impl_m_span,
 192                                            impl_m,
 193                                            &trait_m.generics,
 194                                            &impl_m.generics,
 195                                            &trait_to_skol_substs,
 196                                            impl_to_skol_substs) {
 197         return;
 198     }
 199
 200     tcx.infer_ctxt(None, None, ProjectionMode::AnyFinal).enter(|mut infcx| {
 201         let mut fulfillment_cx = traits::FulfillmentContext::new();
 202
 203         // Normalize the associated types in the trait_bounds.
 204         let trait_bounds = trait_m.predicates.instantiate(tcx, &trait_to_skol_substs);
 205
 206         // Create obligations for each predicate declared by the impl
 207         // definition in the context of the trait's parameter
 208         // environment. We can't just use `impl_env.caller_bounds`,
 209         // however, because we want to replace all late-bound regions with
 210         // region variables.
 211         let impl_bounds =
 212             impl_m.predicates.instantiate(tcx, impl_to_skol_substs);
 213
 214         debug!("compare_impl_method: impl_bounds={:?}", impl_bounds);
 215
 216         // Obtain the predicate split predicate sets for each.
 217         let trait_pred = trait_bounds.predicates.split();
 218         let impl_pred = impl_bounds.predicates.split();
 219
 220         // This is the only tricky bit of the new way we check implementation methods
 221         // We need to build a set of predicates where only the FnSpace bounds
 222         // are from the trait and we assume all other bounds from the implementation
 223         // to be previously satisfied.
 224         //
 225         // We then register the obligations from the impl_m and check to see
 226         // if all constraints hold.
 227         let hybrid_preds = VecPerParamSpace::new(
 228             impl_pred.types,
 229             impl_pred.selfs,
 230             trait_pred.fns
 231         );
 232
 233         // Construct trait parameter environment and then shift it into the skolemized viewpoint.
 234         // The key step here is to update the caller_bounds's predicates to be
 235         // the new hybrid bounds we computed.
 236         let normalize_cause = traits::ObligationCause::misc(impl_m_span, impl_m_body_id);
 237         let trait_param_env = impl_param_env.with_caller_bounds(hybrid_preds.into_vec());
 238         let trait_param_env = traits::normalize_param_env_or_error(tcx,
 239                                                                    trait_param_env,
 240                                                                    normalize_cause.clone());
 241         // FIXME(@jroesch) this seems ugly, but is a temporary change
 242         infcx.parameter_environment = trait_param_env;
 243
 244         debug!("compare_impl_method: trait_bounds={:?}",
 245             infcx.parameter_environment.caller_bounds);
 246
 247         let mut selcx = traits::SelectionContext::new(&infcx);
 248
 249         let (impl_pred_fns, _) =
 250             infcx.replace_late_bound_regions_with_fresh_var(
 251                 impl_m_span,
 252                 infer::HigherRankedType,
 253                 &ty::Binder(impl_pred.fns));
 254         for predicate in impl_pred_fns {
 255             let traits::Normalized { value: predicate, .. } =
 256                 traits::normalize(&mut selcx, normalize_cause.clone(), &predicate);
 257
 258             let cause = traits::ObligationCause {
 259                 span: impl_m_span,
 260                 body_id: impl_m_body_id,
 261                 code: traits::ObligationCauseCode::CompareImplMethodObligation
 262             };
 263
 264             fulfillment_cx.register_predicate_obligation(
 265                 &infcx,
 266                 traits::Obligation::new(cause, predicate));
 267         }
 268
 269         // We now need to check that the signature of the impl method is
 270         // compatible with that of the trait method. We do this by
 271         // checking that `impl_fty <: trait_fty`.
 272         //
 273         // FIXME. Unfortunately, this doesn't quite work right now because
 274         // associated type normalization is not integrated into subtype
 275         // checks. For the comparison to be valid, we need to
 276         // normalize the associated types in the impl/trait methods
 277         // first. However, because function types bind regions, just
 278         // calling `normalize_associated_types_in` would have no effect on
 279         // any associated types appearing in the fn arguments or return
 280         // type.
 281
 282         // Compute skolemized form of impl and trait method tys.
 283         let tcx = infcx.tcx;
 284         let origin = TypeOrigin::MethodCompatCheck(impl_m_span);
 285
 286         let (impl_sig, _) =
 287             infcx.replace_late_bound_regions_with_fresh_var(impl_m_span,
 288                                                             infer::HigherRankedType,
 289                                                             &impl_m.fty.sig);
 290         let impl_sig =
 291             impl_sig.subst(tcx, impl_to_skol_substs);
 292         let impl_sig =
 293             assoc::normalize_associated_types_in(&infcx,
 294                                                  &mut fulfillment_cx,
 295                                                  impl_m_span,
 296                                                  impl_m_body_id,
 297                                                  &impl_sig);
 298         let impl_fty = tcx.mk_fn_ptr(tcx.mk_bare_fn(ty::BareFnTy {
 299             unsafety: impl_m.fty.unsafety,
 300             abi: impl_m.fty.abi,
 301             sig: ty::Binder(impl_sig)
 302         }));
 303         debug!("compare_impl_method: impl_fty={:?}", impl_fty);
 304
 305         let trait_sig = tcx.liberate_late_bound_regions(
 306             infcx.parameter_environment.free_id_outlive,
 307             &trait_m.fty.sig);
 308         let trait_sig =
 309             trait_sig.subst(tcx, &trait_to_skol_substs);
 310         let trait_sig =
 311             assoc::normalize_associated_types_in(&infcx,
 312                                                  &mut fulfillment_cx,
 313                                                  impl_m_span,
 314                                                  impl_m_body_id,
 315                                                  &trait_sig);
 316         let trait_fty = tcx.mk_fn_ptr(tcx.mk_bare_fn(ty::BareFnTy {
 317             unsafety: trait_m.fty.unsafety,
 318             abi: trait_m.fty.abi,
 319             sig: ty::Binder(trait_sig)
 320         }));
 321
 322         debug!("compare_impl_method: trait_fty={:?}", trait_fty);
 323
 324         if let Err(terr) = infcx.sub_types(false, origin, impl_fty, trait_fty) {
 325             debug!("sub_types failed: impl ty {:?}, trait ty {:?}",
 326                    impl_fty,
 327                    trait_fty);
 328
 329             let mut diag = struct_span_err!(
 330                 tcx.sess, origin.span(), E0053,
 331                 "method `{}` has an incompatible type for trait", trait_m.name
 332             );
 333             infcx.note_type_err(
 334                 &mut diag, origin,
 335                 Some(infer::ValuePairs::Types(ExpectedFound {
 336                     expected: trait_fty,
 337                     found: impl_fty
 338                 })), &terr
 339             );
 340             diag.emit();
 341             return
 342         }
 343
 344         // Check that all obligations are satisfied by the implementation's
 345         // version.
 346         if let Err(ref errors) = fulfillment_cx.select_all_or_error(&infcx) {
 347             infcx.report_fulfillment_errors(errors);
 348             return
 349         }
 350
 351         // Finally, resolve all regions. This catches wily misuses of
 352         // lifetime parameters. We have to build up a plausible lifetime
 353         // environment based on what we find in the trait. We could also
 354         // include the obligations derived from the method argument types,
 355         // but I don't think it's necessary -- after all, those are still
 356         // in effect when type-checking the body, and all the
 357         // where-clauses in the header etc should be implied by the trait
 358         // anyway, so it shouldn't be needed there either. Anyway, we can
 359         // always add more relations later (it's backwards compat).
 360         let mut free_regions = FreeRegionMap::new();
 361         free_regions.relate_free_regions_from_predicates(
 362             &infcx.parameter_environment.caller_bounds);
 363
 364         infcx.resolve_regions_and_report_errors(&free_regions, impl_m_body_id);
 365     });
 366
 367     fn check_region_bounds_on_impl_method<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
 368                                                     span: Span,
 369                                                     impl_m: &ty::Method<'tcx>,
 370                                                     trait_generics: &ty::Generics<'tcx>,
 371                                                     impl_generics: &ty::Generics<'tcx>,
 372                                                     trait_to_skol_substs: &Substs<'tcx>,
 373                                                     impl_to_skol_substs: &Substs<'tcx>)
 374                                                     -> bool
 375     {
 376
 377         let trait_params = trait_generics.regions.get_slice(subst::FnSpace);
 378         let impl_params = impl_generics.regions.get_slice(subst::FnSpace);
 379
 380         debug!("check_region_bounds_on_impl_method: \
 381                trait_generics={:?} \
 382                impl_generics={:?} \
 383                trait_to_skol_substs={:?} \
 384                impl_to_skol_substs={:?}",
 385                trait_generics,
 386                impl_generics,
 387                trait_to_skol_substs,
 388                impl_to_skol_substs);
 389
 390         // Must have same number of early-bound lifetime parameters.
 391         // Unfortunately, if the user screws up the bounds, then this
 392         // will change classification between early and late.  E.g.,
 393         // if in trait we have `<'a,'b:'a>`, and in impl we just have
 394         // `<'a,'b>`, then we have 2 early-bound lifetime parameters
 395         // in trait but 0 in the impl. But if we report "expected 2
 396         // but found 0" it's confusing, because it looks like there
 397         // are zero. Since I don't quite know how to phrase things at
 398         // the moment, give a kind of vague error message.
 399         if trait_params.len() != impl_params.len() {
 400             span_err!(ccx.tcx.sess, span, E0195,
 401                 "lifetime parameters or bounds on method `{}` do \
 402                          not match the trait declaration",
 403                          impl_m.name);
 404             return false;
 405         }
 406
 407         return true;
 408     }
 409 }
 410
 411 pub fn compare_const_impl<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
 412                                     impl_c: &ty::AssociatedConst<'tcx>,
 413                                     impl_c_span: Span,
 414                                     trait_c: &ty::AssociatedConst<'tcx>,
 415                                     impl_trait_ref: &ty::TraitRef<'tcx>) {
 416     debug!("compare_const_impl(impl_trait_ref={:?})",
 417            impl_trait_ref);
 418
 419     let tcx = ccx.tcx;
 420     tcx.infer_ctxt(None, None, ProjectionMode::AnyFinal).enter(|infcx| {
 421         let mut fulfillment_cx = traits::FulfillmentContext::new();
 422
 423         // The below is for the most part highly similar to the procedure
 424         // for methods above. It is simpler in many respects, especially
 425         // because we shouldn't really have to deal with lifetimes or
 426         // predicates. In fact some of this should probably be put into
 427         // shared functions because of DRY violations...
 428         let trait_to_impl_substs = &impl_trait_ref.substs;
 429
 430         // Create a parameter environment that represents the implementation's
 431         // method.
 432         let impl_c_node_id = tcx.map.as_local_node_id(impl_c.def_id).unwrap();
 433         let impl_param_env = ty::ParameterEnvironment::for_item(tcx, impl_c_node_id);
 434
 435         // Create mapping from impl to skolemized.
 436         let impl_to_skol_substs = &impl_param_env.free_substs;
 437
 438         // Create mapping from trait to skolemized.
 439         let trait_to_skol_substs =
 440             trait_to_impl_substs
 441             .subst(tcx, impl_to_skol_substs).clone()
 442             .with_method(impl_to_skol_substs.types.get_slice(subst::FnSpace).to_vec(),
 443                          impl_to_skol_substs.regions.get_slice(subst::FnSpace).to_vec());
 444         debug!("compare_const_impl: trait_to_skol_substs={:?}",
 445             trait_to_skol_substs);
 446
 447         // Compute skolemized form of impl and trait const tys.
 448         let impl_ty = impl_c.ty.subst(tcx, impl_to_skol_substs);
 449         let trait_ty = trait_c.ty.subst(tcx, &trait_to_skol_substs);
 450         let origin = TypeOrigin::Misc(impl_c_span);
 451
 452         let err = infcx.commit_if_ok(|_| {
 453             // There is no "body" here, so just pass dummy id.
 454             let impl_ty =
 455                 assoc::normalize_associated_types_in(&infcx,
 456                                                      &mut fulfillment_cx,
 457                                                      impl_c_span,
 458                                                      0,
 459                                                      &impl_ty);
 460
 461             debug!("compare_const_impl: impl_ty={:?}",
 462                 impl_ty);
 463
 464             let trait_ty =
 465                 assoc::normalize_associated_types_in(&infcx,
 466                                                      &mut fulfillment_cx,
 467                                                      impl_c_span,
 468                                                      0,
 469                                                      &trait_ty);
 470
 471             debug!("compare_const_impl: trait_ty={:?}",
 472                 trait_ty);
 473
 474             infcx.sub_types(false, origin, impl_ty, trait_ty)
 475                  .map(|InferOk { obligations, .. }| {
 476                 // FIXME(#32730) propagate obligations
 477                 assert!(obligations.is_empty())
 478             })
 479         });
 480
 481         if let Err(terr) = err {
 482             debug!("checking associated const for compatibility: impl ty {:?}, trait ty {:?}",
 483                    impl_ty,
 484                    trait_ty);
 485             let mut diag = struct_span_err!(
 486                 tcx.sess, origin.span(), E0326,
 487                 "implemented const `{}` has an incompatible type for trait",
 488                 trait_c.name
 489             );
 490             infcx.note_type_err(
 491                 &mut diag, origin,
 492                 Some(infer::ValuePairs::Types(ExpectedFound {
 493                     expected: trait_ty,
 494                     found: impl_ty
 495                 })), &terr
 496             );
 497             diag.emit();
 498         }
 499     });
 500 }