add coherence check for FRTs

Author: BennoLossin

compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs

@@ -7,14 +7,16 @@
 //! `tcx.inherent_impls(def_id)`). That value, however,
 //! is computed by selecting an idea from this table.
 
+use std::ops::ControlFlow;
+
 use rustc_hir as hir;
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::find_attr;
 use rustc_middle::bug;
 use rustc_middle::ty::fast_reject::{SimplifiedType, TreatParams, simplify_type};
-use rustc_middle::ty::{self, CrateInherentImpls, Ty, TyCtxt};
+use rustc_middle::ty::{self, CrateInherentImpls, FieldPath, Ty, TyCtxt};
 use rustc_span::{ErrorGuaranteed, sym};
 
 use crate::errors;
@@ -112,6 +114,40 @@ impl<'tcx> InherentCollect<'tcx> {
         }
     }
 
+    fn check_field_type(
+        &mut self,
+        impl_def_id: LocalDefId,
+        container: Ty<'tcx>,
+        field_path: FieldPath<'tcx>,
+    ) -> Result<(), ErrorGuaranteed> {
+        if !matches!(container.kind(), ty::Adt(..)) {
+            return Err(self
+                .tcx
+                .dcx()
+                .emit_err(errors::InherentTyOutsideNew { span: self.tcx.def_span(impl_def_id) }));
+        }
+        if field_path
+            .walk(self.tcx, container, |base, _, _, _| {
+                if let ty::Adt(def, _) = base.kind()
+                    && !def.did().is_local()
+                {
+                    ControlFlow::Break(())
+                } else {
+                    ControlFlow::Continue(())
+                }
+            })
+            .is_none()
+        {
+            self.impls_map
+                .incoherent_impls
+                .entry(SimplifiedType::Field)
+                .or_default()
+                .push(impl_def_id);
+        }
+
+        Ok(())
+    }
+
     fn check_primitive_impl(
         &mut self,
         impl_def_id: LocalDefId,
@@ -166,6 +202,7 @@ impl<'tcx> InherentCollect<'tcx> {
         }
         match *self_ty.kind() {
             ty::Adt(def, _) => self.check_def_id(id, self_ty, def.did()),
+            ty::Field(container, field_path) => self.check_field_type(id, container, field_path),
             ty::Foreign(did) => self.check_def_id(id, self_ty, did),
             ty::Dynamic(data, ..) if data.principal_def_id().is_some() => {
                 self.check_def_id(id, self_ty, data.principal_def_id().unwrap())

compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -1,6 +1,8 @@
 //! Orphan checker: every impl either implements a trait defined in this
 //! crate or pertains to a type defined in this crate.
 
+use std::ops::ControlFlow;
+
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_errors::ErrorGuaranteed;
 use rustc_infer::infer::{DefineOpaqueTypes, InferCtxt, TyCtxtInferExt};
@@ -151,6 +153,34 @@ pub(crate) fn orphan_check_impl(
                 },
             ),
 
+            ty::Field(container, field_path) => {
+                let non_local_impl = if !matches!(container.kind(), ty::Adt(..)) {
+                    NonlocalImpl::DisallowBecauseNonlocal
+                } else {
+                    field_path
+                    .walk(tcx, *container, |base, _, _, _| match base.kind() {
+                        ty::Adt(def, _) => {
+                            // We don't check the field type for locality, since having a non-local
+                            // type as a field in a struct shouldn't make the field type non-local.
+                            if !def.did().is_local() {
+                                ControlFlow::Break(NonlocalImpl::DisallowBecauseNonlocal)
+                            } else {
+                                ControlFlow::Continue(())
+                            }
+                        }
+                        // Tuples are the only exception.
+                        ty::Tuple(..) => ControlFlow::Continue(()),
+                        _ => {
+                            panic!(
+                                "only adts & tuples are supported by `field_of!` but found: {base}"
+                            )
+                        }
+                    })
+                    .unwrap_or(NonlocalImpl::Allow)
+                };
+                (LocalImpl::Allow, non_local_impl)
+            }
+
             // extern { type OpaqueType; }
             // impl AutoTrait for OpaqueType {}
             ty::Foreign(did) => (

compiler/rustc_next_trait_solver/src/coherence.rs

@@ -419,6 +419,31 @@ where
                     self.found_non_local_ty(ty)
                 }
             }
+            ty::Field(container, field_path) => {
+                if !matches!(container.kind(), ty::Adt(..)) {
+                    self.found_non_local_ty(container)
+                } else {
+                    field_path
+                        .walk(self.infcx.cx(), container, |base, _, _, _| match base.kind() {
+                            ty::Adt(def, _) => {
+                                // We don't check the field type for locality, since having a non-local
+                                // type as a field in a struct shouldn't make the field type non-local.
+                                if !self.def_id_is_local(def.def_id()) {
+                                    ControlFlow::Break(self.found_non_local_ty(base))
+                                } else {
+                                    ControlFlow::Continue(())
+                                }
+                            }
+                            // Tuples are the only exception.
+                            ty::Tuple(..) => ControlFlow::Continue(()),
+                            _ => {
+                                // FIXME(field_projections): no `bug!` available?
+                                panic!("field_path should only consist of tuples and structs for `ty::Field`, but found {base:?}")
+                            }
+                        })
+                        .unwrap_or(ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(container)))
+                }
+            }
             ty::Foreign(def_id) => {
                 if self.def_id_is_local(def_id) {
                     ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty))

tests/ui/field_projections/auxiliary/extern-crate.rs

@@ -0,0 +1,6 @@
+pub struct Point {
+    pub x: usize,
+    pub y: usize,
+}
+
+pub trait ForeignTrait {}

tests/ui/field_projections/incoherent-impl.rs

@@ -0,0 +1,38 @@
+//@ aux-build:extern-crate.rs
+#![allow(incomplete_features)]
+#![feature(field_projections)]
+extern crate extern_crate;
+
+use std::field::field_of;
+
+use extern_crate::{ForeignTrait, Point};
+
+pub trait MyTrait {}
+
+impl MyTrait for field_of!(Point, x) {}
+
+impl extern_crate::ForeignTrait for field_of!(Point, x) {}
+//~^ ERROR: only traits defined in the current crate can be implemented for arbitrary types [E0117]
+
+pub struct Player {
+    pos: Point,
+    hp: (u32, u32),
+}
+
+impl ForeignTrait for field_of!(Player, pos) {}
+
+impl ForeignTrait for field_of!(Player, pos.x) {}
+//~^ ERROR: only traits defined in the current crate can be implemented for arbitrary types [E0117]
+
+impl MyTrait for field_of!(Player, pos) {}
+
+impl MyTrait for field_of!(Player, pos.x) {}
+
+impl MyTrait for field_of!((usize, usize), 0) {}
+
+impl ForeignTrait for field_of!((usize, usize), 0) {}
+//~^ ERROR: only traits defined in the current crate can be implemented for arbitrary types [E0117]
+
+impl ForeignTrait for field_of!(Player, hp.0) {}
+
+fn main() {}

tests/ui/field_projections/incoherent-impl.stderr

@@ -0,0 +1,39 @@
+error[E0117]: only traits defined in the current crate can be implemented for arbitrary types
+  --> $DIR/incoherent-impl.rs:14:1
+   |
+LL | impl extern_crate::ForeignTrait for field_of!(Point, x) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-------------------
+   |                                     |
+   |                                     `Point` is not defined in the current crate
+   |
+   = note: impl doesn't have any local type before any uncovered type parameters
+   = note: for more information see https://doc.rust-lang.org/reference/items/implementations.html#orphan-rules
+   = note: define and implement a trait or new type instead
+
+error[E0117]: only traits defined in the current crate can be implemented for arbitrary types
+  --> $DIR/incoherent-impl.rs:24:1
+   |
+LL | impl ForeignTrait for field_of!(Player, pos.x) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^------------------------
+   |                       |
+   |                       `Point` is not defined in the current crate
+   |
+   = note: impl doesn't have any local type before any uncovered type parameters
+   = note: for more information see https://doc.rust-lang.org/reference/items/implementations.html#orphan-rules
+   = note: define and implement a trait or new type instead
+
+error[E0117]: only traits defined in the current crate can be implemented for arbitrary types
+  --> $DIR/incoherent-impl.rs:33:1
+   |
+LL | impl ForeignTrait for field_of!((usize, usize), 0) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^----------------------------
+   |                       |
+   |                       this is not defined in the current crate because tuples are always foreign
+   |
+   = note: impl doesn't have any local type before any uncovered type parameters
+   = note: for more information see https://doc.rust-lang.org/reference/items/implementations.html#orphan-rules
+   = note: define and implement a trait or new type instead
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0117`.