The allow-by-default lint `missing_copy_implementations` does not honor `!Copy` impls

[fmease]

I would expect the following code to compile successfully since we explicitly opt out of implementing Copy:

#![feature(negative_impls)]
#![deny(missing_copy_implementations)]
#![crate_type = "lib"]

pub struct Struct {
    pub field: i32,
}

impl !Copy for Struct {}

However, the code fails to compile with the following error message:

error: type could implement `Copy`; consider adding `impl Copy`
 --> src/lib.rs:5:1
  |
5 | / pub struct Struct {
6 | |     pub field: i32,
7 | | }
  | |_^
  |
note: the lint level is defined here
 --> src/lib.rs:2:9
  |
2 | #![deny(missing_copy_implementations)]
  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

@rustbot label C-bug A-lint F-negative_impls

[fmease]

The compiler only checks if the type implements Copy already to return early and not emit the lint diagnostic but it doesn't check if the type implements !Copy:

rust/compiler/rustc_lint/src/builtin.rs

Line 753 in 4af79cc

if ty.is_copy_modulo_regions(cx.tcx.at(item.span), param_env) {

[vincenzopalazzo]

I think this makes the trick, you are right! the last think is to explore what is the code of the method

rust/compiler/rustc_middle/src/ty/util.rs

Lines 824 to 830 in 9b0a099

	pub fn is_copy_modulo_regions(
	self,
	tcx_at: TyCtxtAt<'tcx>,
	param_env: ty::ParamEnv<'tcx>,
	) -> bool {
	self.is_trivially_pure_clone_copy() || tcx_at.is_copy_raw(param_env.and(self))
	}

The code of the method looks not so trivial :)

rust/compiler/rustc_middle/src/ty/sty.rs

Lines 2201 to 2245 in 3271760

	pub fn is_trivially_pure_clone_copy(self) -> bool {
	match self.kind() {
	ty::Bool | ty::Char | ty::Never => true,
	// These aren't even `Clone`
	ty::Str | ty::Slice(..) | ty::Foreign(..) | ty::Dynamic(..) => false,
	ty::Infer(ty::InferTy::FloatVar(_) | ty::InferTy::IntVar(_))
	| ty::Int(..)
	| ty::Uint(..)
	| ty::Float(..) => true,
	// The voldemort ZSTs are fine.
	ty::FnDef(..) => true,
	ty::Array(element_ty, _len) => element_ty.is_trivially_pure_clone_copy(),
	// A 100-tuple isn't "trivial", so doing this only for reasonable sizes.
	ty::Tuple(field_tys) => {
	field_tys.len() <= 3 && field_tys.iter().all(Self::is_trivially_pure_clone_copy)
	}
	// Sometimes traits aren't implemented for every ABI or arity,
	// because we can't be generic over everything yet.
	ty::FnPtr(..) => false,
	// Definitely absolutely not copy.
	ty::Ref(_, _, hir::Mutability::Mut) => false,
	// Thin pointers & thin shared references are pure-clone-copy, but for
	// anything with custom metadata it might be more complicated.
	ty::Ref(_, _, hir::Mutability::Not) | ty::RawPtr(..) => false,
	ty::Generator(..) | ty::GeneratorWitness(..) => false,
	// Might be, but not "trivial" so just giving the safe answer.
	ty::Adt(..) | ty::Closure(..) | ty::Opaque(..) => false,
	ty::Projection(..) | ty::Param(..) | ty::Infer(..) | ty::Error(..) => false,
	ty::Bound(..) | ty::Placeholder(..) => {
	bug!("`is_trivially_pure_clone_copy` applied to unexpected type: {:?}", self);
	}
	}
	}

If you did not find already I can play with your on it by mentoring you, I had some experience in "git archeology" :)

@rustbot label +E-mentor

[Kohei316]

@rustbot claim