lint ImproperCTypes: add considerations for which values can be sourced from non-rust code

Author: niacdoial

compiler/rustc_lint/messages.ftl

@@ -411,8 +411,13 @@ lint_improper_ctypes_only_phantomdata = composed only of `PhantomData`
 
 lint_improper_ctypes_opaque = opaque types have no C equivalent
 
-lint_improper_ctypes_pat_help = consider using the base type instead
-lint_improper_ctypes_pat_reason = pattern types have no C equivalent
+lint_improper_ctypes_pat_intrange_help = consider using the base type instead
+lint_improper_ctypes_pat_intrange_reason = integers constrained to a given range cannot have their value be provided by non-rust code
+
+lint_improper_ctypes_ptr_validity_help = consider using a raw pointer, or wrapping `{$ty}` in an `Option<_>`
+lint_improper_ctypes_ptr_validity_reason =
+    boxes and references are assumed to be valid (non-null, non-dangling, aligned) pointers,
+    which cannot be garanteed if their values are produced by non-rust code
 
 lint_improper_ctypes_sized_ptr_to_unsafe_type =
     this reference (`{$ty}`) is ABI-compatible with a C pointer, but `{$inner_ty}` itself does not have a C layout

compiler/rustc_lint/src/types.rs

@@ -4,7 +4,7 @@ use rustc_abi::{BackendRepr, TagEncoding, Variants, WrappingRange};
 use rustc_hir::{Expr, ExprKind, HirId, LangItem};
 use rustc_middle::bug;
 use rustc_middle::ty::layout::{LayoutOf, SizeSkeleton};
-use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{self, AdtKind, Ty, TyCtxt, TypeVisitableExt};
 use rustc_session::{declare_lint, declare_lint_pass, impl_lint_pass};
 use rustc_span::{Span, Symbol, sym};
 use tracing::debug;
@@ -929,6 +929,38 @@ fn get_nullable_type_from_pat<'tcx>(
     }
 }
 
+/// determines wether or not `outer_ty` is an option-like enum, with the same size as its contained type, `ty`.
+/// this ASSUMES that `ty` is a type that is already 'inside' of `outer_ty`.
+fn is_outer_optionlike_around_ty<'tcx>(
+    cx: &LateContext<'tcx>,
+    outer_ty: Ty<'tcx>,
+    ty: Ty<'tcx>,
+) -> bool {
+    // three things to check to be sure outer_ty is option-like (since we know we reached the current ty from there)
+    // That outer_ty is an enum, that this enum doesn't have a defined discriminant representation,
+    // and the the outer_ty's size is that of ty.
+    if let ty::Adt(def, _) = outer_ty.kind() {
+        if !matches!(def.adt_kind(), AdtKind::Enum)
+            || def.repr().c()
+            || def.repr().transparent()
+            || def.repr().int.is_none()
+        {
+            false
+        } else {
+            let (tcx, typing_env) = (cx.tcx, cx.typing_env());
+
+            // see the insides of super::repr_nullable_ptr()
+            let compute_size_skeleton = |t| SizeSkeleton::compute(t, tcx, typing_env).ok();
+            match (compute_size_skeleton(ty), compute_size_skeleton(outer_ty)) {
+                (Some(sk1), Some(sk2)) => sk1.same_size(sk2),
+                _ => false,
+            }
+        }
+    } else {
+        false
+    }
+}
+
 declare_lint_pass!(VariantSizeDifferences => [VARIANT_SIZE_DIFFERENCES]);
 
 impl<'tcx> LateLintPass<'tcx> for VariantSizeDifferences {