src/librustc_typeck/coherence/builtin.rs

   1 //! Check properties that are required by built-in traits and set
   2 //! up data structures required by type-checking/codegen.
   3
   4 use rustc::infer::SuppressRegionErrors;
   5 use rustc::infer::outlives::env::OutlivesEnvironment;
   6 use rustc::middle::region;
   7 use rustc::middle::lang_items::UnsizeTraitLangItem;
   8
   9 use rustc::traits::{self, TraitEngine, ObligationCause};
  10 use rustc::ty::{self, Ty, TyCtxt};
  11 use rustc::ty::TypeFoldable;
  12 use rustc::ty::adjustment::CoerceUnsizedInfo;
  13 use rustc::ty::util::CopyImplementationError;
  14 use rustc::infer;
  15
  16 use rustc::hir::def_id::DefId;
  17 use hir::Node;
  18 use rustc::hir::{self, ItemKind};
  19
  20 pub fn check_trait(tcx: TyCtxt<'_>, trait_def_id: DefId) {
  21     Checker { tcx, trait_def_id }
  22         .check(tcx.lang_items().drop_trait(), visit_implementation_of_drop)
  23         .check(tcx.lang_items().copy_trait(), visit_implementation_of_copy)
  24         .check(tcx.lang_items().coerce_unsized_trait(), visit_implementation_of_coerce_unsized)
  25         .check(tcx.lang_items().dispatch_from_dyn_trait(),
  26             visit_implementation_of_dispatch_from_dyn);
  27 }
  28
  29 struct Checker<'tcx> {
  30     tcx: TyCtxt<'tcx>,
  31     trait_def_id: DefId,
  32 }
  33
  34 impl<'tcx> Checker<'tcx> {
  35     fn check<F>(&self, trait_def_id: Option<DefId>, mut f: F) -> &Self
  36     where
  37         F: FnMut(TyCtxt<'tcx>, DefId),
  38     {
  39         if Some(self.trait_def_id) == trait_def_id {
  40             for &impl_id in self.tcx.hir().trait_impls(self.trait_def_id) {
  41                 let impl_def_id = self.tcx.hir().local_def_id(impl_id);
  42                 f(self.tcx, impl_def_id);
  43             }
  44         }
  45         self
  46     }
  47 }
  48
  49 fn visit_implementation_of_drop(tcx: TyCtxt<'_>, impl_did: DefId) {
  50     if let ty::Adt(..) = tcx.type_of(impl_did).kind {
  51         /* do nothing */
  52     } else {
  53         // Destructors only work on nominal types.
  54         if let Some(impl_hir_id) = tcx.hir().as_local_hir_id(impl_did) {
  55             if let Some(Node::Item(item)) = tcx.hir().find(impl_hir_id) {
  56                 let span = match item.node {
  57                     ItemKind::Impl(.., ref ty, _) => ty.span,
  58                     _ => item.span,
  59                 };
  60                 struct_span_err!(tcx.sess,
  61                                  span,
  62                                  E0120,
  63                                  "the Drop trait may only be implemented on \
  64                                   structures")
  65                     .span_label(span, "implementing Drop requires a struct")
  66                     .emit();
  67             } else {
  68                 bug!("didn't find impl in ast map");
  69             }
  70         } else {
  71             bug!("found external impl of Drop trait on \
  72                   something other than a struct");
  73         }
  74     }
  75 }
  76
  77 fn visit_implementation_of_copy(tcx: TyCtxt<'_>, impl_did: DefId) {
  78     debug!("visit_implementation_of_copy: impl_did={:?}", impl_did);
  79
  80     let impl_hir_id = if let Some(n) = tcx.hir().as_local_hir_id(impl_did) {
  81         n
  82     } else {
  83         debug!("visit_implementation_of_copy(): impl not in this crate");
  84         return;
  85     };
  86
  87     let self_type = tcx.type_of(impl_did);
  88     debug!("visit_implementation_of_copy: self_type={:?} (bound)",
  89            self_type);
  90
  91     let span = tcx.hir().span(impl_hir_id);
  92     let param_env = tcx.param_env(impl_did);
  93     assert!(!self_type.has_escaping_bound_vars());
  94
  95     debug!("visit_implementation_of_copy: self_type={:?} (free)",
  96            self_type);
  97
  98     match param_env.can_type_implement_copy(tcx, self_type) {
  99         Ok(()) => {}
 100         Err(CopyImplementationError::InfrigingFields(fields)) => {
 101             let item = tcx.hir().expect_item(impl_hir_id);
 102             let span = if let ItemKind::Impl(.., Some(ref tr), _, _) = item.node {
 103                 tr.path.span
 104             } else {
 105                 span
 106             };
 107
 108             let mut err = struct_span_err!(tcx.sess,
 109                                            span,
 110                                            E0204,
 111                                            "the trait `Copy` may not be implemented for this type");
 112             for span in fields.iter().map(|f| tcx.def_span(f.did)) {
 113                 err.span_label(span, "this field does not implement `Copy`");
 114             }
 115             err.emit()
 116         }
 117         Err(CopyImplementationError::NotAnAdt) => {
 118             let item = tcx.hir().expect_item(impl_hir_id);
 119             let span = if let ItemKind::Impl(.., ref ty, _) = item.node {
 120                 ty.span
 121             } else {
 122                 span
 123             };
 124
 125             struct_span_err!(tcx.sess,
 126                              span,
 127                              E0206,
 128                              "the trait `Copy` may not be implemented for this type")
 129                 .span_label(span, "type is not a structure or enumeration")
 130                 .emit();
 131         }
 132         Err(CopyImplementationError::HasDestructor) => {
 133             struct_span_err!(tcx.sess,
 134                              span,
 135                              E0184,
 136                              "the trait `Copy` may not be implemented for this type; the \
 137                               type has a destructor")
 138                 .span_label(span, "Copy not allowed on types with destructors")
 139                 .emit();
 140         }
 141     }
 142 }
 143
 144 fn visit_implementation_of_coerce_unsized(tcx: TyCtxt<'tcx>, impl_did: DefId) {
 145     debug!("visit_implementation_of_coerce_unsized: impl_did={:?}",
 146            impl_did);
 147
 148     // Just compute this for the side-effects, in particular reporting
 149     // errors; other parts of the code may demand it for the info of
 150     // course.
 151     if impl_did.is_local() {
 152         let span = tcx.def_span(impl_did);
 153         tcx.at(span).coerce_unsized_info(impl_did);
 154     }
 155 }
 156
 157 fn visit_implementation_of_dispatch_from_dyn(tcx: TyCtxt<'_>, impl_did: DefId) {
 158     debug!("visit_implementation_of_dispatch_from_dyn: impl_did={:?}",
 159            impl_did);
 160     if impl_did.is_local() {
 161         let dispatch_from_dyn_trait = tcx.lang_items().dispatch_from_dyn_trait().unwrap();
 162
 163         let impl_hir_id = tcx.hir().as_local_hir_id(impl_did).unwrap();
 164         let span = tcx.hir().span(impl_hir_id);
 165
 166         let source = tcx.type_of(impl_did);
 167         assert!(!source.has_escaping_bound_vars());
 168         let target = {
 169             let trait_ref = tcx.impl_trait_ref(impl_did).unwrap();
 170             assert_eq!(trait_ref.def_id, dispatch_from_dyn_trait);
 171
 172             trait_ref.substs.type_at(1)
 173         };
 174
 175         debug!("visit_implementation_of_dispatch_from_dyn: {:?} -> {:?}",
 176             source,
 177             target);
 178
 179         let param_env = tcx.param_env(impl_did);
 180
 181         let create_err = |msg: &str| {
 182             struct_span_err!(tcx.sess, span, E0378, "{}", msg)
 183         };
 184
 185         tcx.infer_ctxt().enter(|infcx| {
 186             let cause = ObligationCause::misc(span, impl_hir_id);
 187
 188             use ty::TyKind::*;
 189             match (&source.kind, &target.kind) {
 190                 (&Ref(r_a, _, mutbl_a), Ref(r_b, _, mutbl_b))
 191                     if infcx.at(&cause, param_env).eq(r_a, r_b).is_ok()
 192                     && mutbl_a == *mutbl_b => (),
 193                 (&RawPtr(tm_a), &RawPtr(tm_b))
 194                     if tm_a.mutbl == tm_b.mutbl => (),
 195                 (&Adt(def_a, substs_a), &Adt(def_b, substs_b))
 196                     if def_a.is_struct() && def_b.is_struct() =>
 197                 {
 198                     if def_a != def_b {
 199                         let source_path = tcx.def_path_str(def_a.did);
 200                         let target_path = tcx.def_path_str(def_b.did);
 201
 202                         create_err(
 203                             &format!(
 204                                 "the trait `DispatchFromDyn` may only be implemented \
 205                                 for a coercion between structures with the same \
 206                                 definition; expected `{}`, found `{}`",
 207                                 source_path, target_path,
 208                             )
 209                         ).emit();
 210
 211                         return
 212                     }
 213
 214                     if def_a.repr.c() || def_a.repr.packed() {
 215                         create_err(
 216                             "structs implementing `DispatchFromDyn` may not have \
 217                              `#[repr(packed)]` or `#[repr(C)]`"
 218                         ).emit();
 219                     }
 220
 221                     let fields = &def_a.non_enum_variant().fields;
 222
 223                     let coerced_fields = fields.iter().filter_map(|field| {
 224                         let ty_a = field.ty(tcx, substs_a);
 225                         let ty_b = field.ty(tcx, substs_b);
 226
 227                         if let Ok(layout) = tcx.layout_of(param_env.and(ty_a)) {
 228                             if layout.is_zst() && layout.details.align.abi.bytes() == 1 {
 229                                 // ignore ZST fields with alignment of 1 byte
 230                                 return None;
 231                             }
 232                         }
 233
 234                         if let Ok(ok) = infcx.at(&cause, param_env).eq(ty_a, ty_b) {
 235                             if ok.obligations.is_empty() {
 236                                 create_err(
 237                                     "the trait `DispatchFromDyn` may only be implemented \
 238                                      for structs containing the field being coerced, \
 239                                      ZST fields with 1 byte alignment, and nothing else"
 240                                 ).note(
 241                                     &format!(
 242                                         "extra field `{}` of type `{}` is not allowed",
 243                                         field.ident, ty_a,
 244                                     )
 245                                 ).emit();
 246
 247                                 return None;
 248                             }
 249                         }
 250
 251                         Some(field)
 252                     }).collect::<Vec<_>>();
 253
 254                     if coerced_fields.is_empty() {
 255                         create_err(
 256                             "the trait `DispatchFromDyn` may only be implemented \
 257                             for a coercion between structures with a single field \
 258                             being coerced, none found"
 259                         ).emit();
 260                     } else if coerced_fields.len() > 1 {
 261                         create_err(
 262                             "implementing the `DispatchFromDyn` trait requires multiple coercions",
 263                         ).note(
 264                             "the trait `DispatchFromDyn` may only be implemented \
 265                                 for a coercion between structures with a single field \
 266                                 being coerced"
 267                         ).note(
 268                             &format!(
 269                                 "currently, {} fields need coercions: {}",
 270                                 coerced_fields.len(),
 271                                 coerced_fields.iter().map(|field| {
 272                                     format!("`{}` (`{}` to `{}`)",
 273                                         field.ident,
 274                                         field.ty(tcx, substs_a),
 275                                         field.ty(tcx, substs_b),
 276                                     )
 277                                 }).collect::<Vec<_>>()
 278                                 .join(", ")
 279                             )
 280                         ).emit();
 281                     } else {
 282                         let mut fulfill_cx = TraitEngine::new(infcx.tcx);
 283
 284                         for field in coerced_fields {
 285
 286                             let predicate = tcx.predicate_for_trait_def(
 287                                 param_env,
 288                                 cause.clone(),
 289                                 dispatch_from_dyn_trait,
 290                                 0,
 291                                 field.ty(tcx, substs_a),
 292                                 &[field.ty(tcx, substs_b).into()]
 293                             );
 294
 295                             fulfill_cx.register_predicate_obligation(&infcx, predicate);
 296                         }
 297
 298                         // Check that all transitive obligations are satisfied.
 299                         if let Err(errors) = fulfill_cx.select_all_or_error(&infcx) {
 300                             infcx.report_fulfillment_errors(&errors, None, false);
 301                         }
 302
 303                         // Finally, resolve all regions.
 304                         let region_scope_tree = region::ScopeTree::default();
 305                         let outlives_env = OutlivesEnvironment::new(param_env);
 306                         infcx.resolve_regions_and_report_errors(
 307                             impl_did,
 308                             &region_scope_tree,
 309                             &outlives_env,
 310                             SuppressRegionErrors::default(),
 311                         );
 312                     }
 313                 }
 314                 _ => {
 315                     create_err(
 316                         "the trait `DispatchFromDyn` may only be implemented \
 317                         for a coercion between structures"
 318                     ).emit();
 319                 }
 320             }
 321         })
 322     }
 323 }
 324
 325 pub fn coerce_unsized_info<'tcx>(gcx: TyCtxt<'tcx>, impl_did: DefId) -> CoerceUnsizedInfo {
 326     debug!("compute_coerce_unsized_info(impl_did={:?})", impl_did);
 327     let coerce_unsized_trait = gcx.lang_items().coerce_unsized_trait().unwrap();
 328
 329     let unsize_trait = gcx.lang_items().require(UnsizeTraitLangItem).unwrap_or_else(|err| {
 330         gcx.sess.fatal(&format!("`CoerceUnsized` implementation {}", err));
 331     });
 332
 333     // this provider should only get invoked for local def-ids
 334     let impl_hir_id = gcx.hir().as_local_hir_id(impl_did).unwrap_or_else(|| {
 335         bug!("coerce_unsized_info: invoked for non-local def-id {:?}", impl_did)
 336     });
 337
 338     let source = gcx.type_of(impl_did);
 339     let trait_ref = gcx.impl_trait_ref(impl_did).unwrap();
 340     assert_eq!(trait_ref.def_id, coerce_unsized_trait);
 341     let target = trait_ref.substs.type_at(1);
 342     debug!("visit_implementation_of_coerce_unsized: {:?} -> {:?} (bound)",
 343            source,
 344            target);
 345
 346     let span = gcx.hir().span(impl_hir_id);
 347     let param_env = gcx.param_env(impl_did);
 348     assert!(!source.has_escaping_bound_vars());
 349
 350     let err_info = CoerceUnsizedInfo { custom_kind: None };
 351
 352     debug!("visit_implementation_of_coerce_unsized: {:?} -> {:?} (free)",
 353            source,
 354            target);
 355
 356     gcx.infer_ctxt().enter(|infcx| {
 357         let cause = ObligationCause::misc(span, impl_hir_id);
 358         let check_mutbl = |mt_a: ty::TypeAndMut<'tcx>,
 359                            mt_b: ty::TypeAndMut<'tcx>,
 360                            mk_ptr: &dyn Fn(Ty<'tcx>) -> Ty<'tcx>| {
 361             if (mt_a.mutbl, mt_b.mutbl) == (hir::MutImmutable, hir::MutMutable) {
 362                 infcx.report_mismatched_types(&cause,
 363                                               mk_ptr(mt_b.ty),
 364                                               target,
 365                                               ty::error::TypeError::Mutability)
 366                     .emit();
 367             }
 368             (mt_a.ty, mt_b.ty, unsize_trait, None)
 369         };
 370         let (source, target, trait_def_id, kind) = match (&source.kind, &target.kind) {
 371             (&ty::Ref(r_a, ty_a, mutbl_a), &ty::Ref(r_b, ty_b, mutbl_b)) => {
 372                 infcx.sub_regions(infer::RelateObjectBound(span), r_b, r_a);
 373                 let mt_a = ty::TypeAndMut { ty: ty_a, mutbl: mutbl_a };
 374                 let mt_b = ty::TypeAndMut { ty: ty_b, mutbl: mutbl_b };
 375                 check_mutbl(mt_a, mt_b, &|ty| gcx.mk_imm_ref(r_b, ty))
 376             }
 377
 378             (&ty::Ref(_, ty_a, mutbl_a), &ty::RawPtr(mt_b)) => {
 379                 let mt_a = ty::TypeAndMut { ty: ty_a, mutbl: mutbl_a };
 380                 check_mutbl(mt_a, mt_b, &|ty| gcx.mk_imm_ptr(ty))
 381             }
 382
 383             (&ty::RawPtr(mt_a), &ty::RawPtr(mt_b)) => {
 384                 check_mutbl(mt_a, mt_b, &|ty| gcx.mk_imm_ptr(ty))
 385             }
 386
 387             (&ty::Adt(def_a, substs_a), &ty::Adt(def_b, substs_b)) if def_a.is_struct() &&
 388                                                                       def_b.is_struct() => {
 389                 if def_a != def_b {
 390                     let source_path = gcx.def_path_str(def_a.did);
 391                     let target_path = gcx.def_path_str(def_b.did);
 392                     span_err!(gcx.sess,
 393                               span,
 394                               E0377,
 395                               "the trait `CoerceUnsized` may only be implemented \
 396                                for a coercion between structures with the same \
 397                                definition; expected `{}`, found `{}`",
 398                               source_path,
 399                               target_path);
 400                     return err_info;
 401                 }
 402
 403                 // Here we are considering a case of converting
 404                 // `S<P0...Pn>` to S<Q0...Qn>`. As an example, let's imagine a struct `Foo<T, U>`,
 405                 // which acts like a pointer to `U`, but carries along some extra data of type `T`:
 406                 //
 407                 //     struct Foo<T, U> {
 408                 //         extra: T,
 409                 //         ptr: *mut U,
 410                 //     }
 411                 //
 412                 // We might have an impl that allows (e.g.) `Foo<T, [i32; 3]>` to be unsized
 413                 // to `Foo<T, [i32]>`. That impl would look like:
 414                 //
 415                 //   impl<T, U: Unsize<V>, V> CoerceUnsized<Foo<T, V>> for Foo<T, U> {}
 416                 //
 417                 // Here `U = [i32; 3]` and `V = [i32]`. At runtime,
 418                 // when this coercion occurs, we would be changing the
 419                 // field `ptr` from a thin pointer of type `*mut [i32;
 420                 // 3]` to a fat pointer of type `*mut [i32]` (with
 421                 // extra data `3`).  **The purpose of this check is to
 422                 // make sure that we know how to do this conversion.**
 423                 //
 424                 // To check if this impl is legal, we would walk down
 425                 // the fields of `Foo` and consider their types with
 426                 // both substitutes. We are looking to find that
 427                 // exactly one (non-phantom) field has changed its
 428                 // type, which we will expect to be the pointer that
 429                 // is becoming fat (we could probably generalize this
 430                 // to multiple thin pointers of the same type becoming
 431                 // fat, but we don't). In this case:
 432                 //
 433                 // - `extra` has type `T` before and type `T` after
 434                 // - `ptr` has type `*mut U` before and type `*mut V` after
 435                 //
 436                 // Since just one field changed, we would then check
 437                 // that `*mut U: CoerceUnsized<*mut V>` is implemented
 438                 // (in other words, that we know how to do this
 439                 // conversion). This will work out because `U:
 440                 // Unsize<V>`, and we have a builtin rule that `*mut
 441                 // U` can be coerced to `*mut V` if `U: Unsize<V>`.
 442                 let fields = &def_a.non_enum_variant().fields;
 443                 let diff_fields = fields.iter()
 444                     .enumerate()
 445                     .filter_map(|(i, f)| {
 446                         let (a, b) = (f.ty(gcx, substs_a), f.ty(gcx, substs_b));
 447
 448                         if gcx.type_of(f.did).is_phantom_data() {
 449                             // Ignore PhantomData fields
 450                             return None;
 451                         }
 452
 453                         // Ignore fields that aren't changed; it may
 454                         // be that we could get away with subtyping or
 455                         // something more accepting, but we use
 456                         // equality because we want to be able to
 457                         // perform this check without computing
 458                         // variance where possible. (This is because
 459                         // we may have to evaluate constraint
 460                         // expressions in the course of execution.)
 461                         // See e.g., #41936.
 462                         if let Ok(ok) = infcx.at(&cause, param_env).eq(a, b) {
 463                             if ok.obligations.is_empty() {
 464                                 return None;
 465                             }
 466                         }
 467
 468                         // Collect up all fields that were significantly changed
 469                         // i.e., those that contain T in coerce_unsized T -> U
 470                         Some((i, a, b))
 471                     })
 472                     .collect::<Vec<_>>();
 473
 474                 if diff_fields.is_empty() {
 475                     span_err!(gcx.sess,
 476                               span,
 477                               E0374,
 478                               "the trait `CoerceUnsized` may only be implemented \
 479                                for a coercion between structures with one field \
 480                                being coerced, none found");
 481                     return err_info;
 482                 } else if diff_fields.len() > 1 {
 483                     let item = gcx.hir().expect_item(impl_hir_id);
 484                     let span = if let ItemKind::Impl(.., Some(ref t), _, _) = item.node {
 485                         t.path.span
 486                     } else {
 487                         gcx.hir().span(impl_hir_id)
 488                     };
 489
 490                     let mut err = struct_span_err!(gcx.sess,
 491                                                    span,
 492                                                    E0375,
 493                                                    "implementing the trait \
 494                                                     `CoerceUnsized` requires multiple \
 495                                                     coercions");
 496                     err.note("`CoerceUnsized` may only be implemented for \
 497                               a coercion between structures with one field being coerced");
 498                     err.note(&format!("currently, {} fields need coercions: {}",
 499                                       diff_fields.len(),
 500                                       diff_fields.iter()
 501                                           .map(|&(i, a, b)| {
 502                                               format!("`{}` (`{}` to `{}`)", fields[i].ident, a, b)
 503                                           })
 504                                           .collect::<Vec<_>>()
 505                                           .join(", ")));
 506                     err.span_label(span, "requires multiple coercions");
 507                     err.emit();
 508                     return err_info;
 509                 }
 510
 511                 let (i, a, b) = diff_fields[0];
 512                 let kind = ty::adjustment::CustomCoerceUnsized::Struct(i);
 513                 (a, b, coerce_unsized_trait, Some(kind))
 514             }
 515
 516             _ => {
 517                 span_err!(gcx.sess,
 518                           span,
 519                           E0376,
 520                           "the trait `CoerceUnsized` may only be implemented \
 521                            for a coercion between structures");
 522                 return err_info;
 523             }
 524         };
 525
 526         let mut fulfill_cx = TraitEngine::new(infcx.tcx);
 527
 528         // Register an obligation for `A: Trait<B>`.
 529         let cause = traits::ObligationCause::misc(span, impl_hir_id);
 530         let predicate = gcx.predicate_for_trait_def(param_env,
 531                                                     cause,
 532                                                     trait_def_id,
 533                                                     0,
 534                                                     source,
 535                                                     &[target.into()]);
 536         fulfill_cx.register_predicate_obligation(&infcx, predicate);
 537
 538         // Check that all transitive obligations are satisfied.
 539         if let Err(errors) = fulfill_cx.select_all_or_error(&infcx) {
 540             infcx.report_fulfillment_errors(&errors, None, false);
 541         }
 542
 543         // Finally, resolve all regions.
 544         let region_scope_tree = region::ScopeTree::default();
 545         let outlives_env = OutlivesEnvironment::new(param_env);
 546         infcx.resolve_regions_and_report_errors(
 547             impl_did,
 548             &region_scope_tree,
 549             &outlives_env,
 550             SuppressRegionErrors::default(),
 551         );
 552
 553         CoerceUnsizedInfo {
 554             custom_kind: kind
 555         }
 556     })
 557 }