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