Actually create ranged int types in the type system.

Author: oli-obk

compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -194,6 +194,15 @@ fn push_debuginfo_type_name<'tcx>(
                 }
             }
         }
+        ty::Pat(inner_type, pat) => {
+            if cpp_like_debuginfo {
+                output.push_str("pat$<");
+                push_debuginfo_type_name(tcx, inner_type, true, output, visited);
+                write!(output, ",{:?}>", pat).unwrap();
+            } else {
+                write!(output, "{:?}", t).unwrap();
+            }
+        }
         ty::Slice(inner_type) => {
             if cpp_like_debuginfo {
                 output.push_str("slice2$<");

compiler/rustc_const_eval/src/const_eval/valtrees.rs

@@ -96,6 +96,8 @@ pub(crate) fn const_to_valtree_inner<'tcx>(
             Ok(ty::ValTree::Leaf(val.assert_int()))
         }
 
+        ty::Pat(..) => const_to_valtree_inner(ecx, &ecx.mplace_field(&place, 0).unwrap(), num_nodes),
+
         // Raw pointers are not allowed in type level constants, as we cannot properly test them for
         // equality at compile-time (see `ptr_guaranteed_cmp`).
         // Technically we could allow function pointers (represented as `ty::Instance`), but this is not guaranteed to
@@ -265,7 +267,7 @@ pub fn valtree_to_const_value<'tcx>(
     let (param_env, ty) = param_env_ty.into_parts();
     let mut ecx = mk_eval_cx(tcx, DUMMY_SP, param_env, false);
 
-    match ty.kind() {
+    match *ty.kind() {
         ty::FnDef(..) => {
             assert!(valtree.unwrap_branch().is_empty());
             ConstValue::ZeroSized
@@ -276,6 +278,7 @@ pub fn valtree_to_const_value<'tcx>(
                 "ValTrees for Bool, Int, Uint, Float or Char should have the form ValTree::Leaf"
             ),
         },
+        ty::Pat(ty, _) => valtree_to_const_value(tcx, param_env.and(ty), valtree),
         ty::Ref(_, _, _) | ty::Tuple(_) | ty::Array(_, _) | ty::Adt(..) => {
             let mut place = match ty.kind() {
                 ty::Ref(_, inner_ty, _) => {

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -83,6 +83,9 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
             ty::Alias(..) | ty::Param(_) | ty::Placeholder(_) | ty::Infer(_) => {
                 throw_inval!(TooGeneric)
             }
+            ty::Pat(..) => {
+                unimplemented!("pattern types need to calculate pattern from their pattern")
+            }
             ty::Bound(_, _) => bug!("bound ty during ctfe"),
             ty::Bool
             | ty::Char

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -584,6 +584,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
                 // Nothing to check.
                 Ok(true)
             }
+            ty::Pat(..) => unimplemented!(),
             // The above should be all the primitive types. The rest is compound, we
             // check them by visiting their fields/variants.
             ty::Adt(..)

compiler/rustc_const_eval/src/util/type_name.rs

@@ -40,6 +40,7 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
             | ty::Uint(_)
             | ty::Float(_)
             | ty::Str
+            | ty::Pat(_, _)
             | ty::Array(_, _)
             | ty::Slice(_)
             | ty::RawPtr(_)

compiler/rustc_error_messages/locales/en-US/hir_analysis.ftl

@@ -127,3 +127,5 @@ hir_analysis_auto_deref_reached_recursion_limit = reached the recursion limit wh
 
 hir_analysis_pattern_type_wild_pat = "wildcard patterns are not permitted for pattern types"
     .label = "this type is the same as the inner type without a pattern"
+
+hir_analysis_pattern_type_non_const_range = "range patterns must have constant range start and end"

compiler/rustc_error_messages/locales/en-US/lint.ftl

@@ -239,6 +239,9 @@ lint_improper_ctypes_128bit = 128-bit integers don't currently have a known stab
 lint_improper_ctypes_char_reason = the `char` type has no C equivalent
 lint_improper_ctypes_char_help = consider using `u32` or `libc::wchar_t` instead
 
+lint_improper_ctypes_pat_reason = pattern types have no C equivalent
+lint_improper_ctypes_pat_help = consider using the patterned type instead
+
 lint_improper_ctypes_non_exhaustive = this enum is non-exhaustive
 lint_improper_ctypes_non_exhaustive_variant = this enum has non-exhaustive variants
 

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -11,8 +11,9 @@ use crate::astconv::generics::{
 use crate::bounds::Bounds;
 use crate::collect::HirPlaceholderCollector;
 use crate::errors::{
-    AmbiguousLifetimeBound, MultipleRelaxedDefaultBounds, TraitObjectDeclaredWithNoTraits,
-    TypeofReservedKeywordUsed, ValueOfAssociatedStructAlreadySpecified, WildPatTy,
+    AmbiguousLifetimeBound, MultipleRelaxedDefaultBounds, NonConstRange,
+    TraitObjectDeclaredWithNoTraits, TypeofReservedKeywordUsed,
+    ValueOfAssociatedStructAlreadySpecified, WildPatTy,
 };
 use crate::middle::resolve_lifetime as rl;
 use crate::require_c_abi_if_c_variadic;
@@ -29,6 +30,7 @@ use rustc_hir::intravisit::{walk_generics, Visitor as _};
 use rustc_hir::{GenericArg, GenericArgs, OpaqueTyOrigin};
 use rustc_infer::infer::{InferCtxt, TyCtxtInferExt};
 use rustc_middle::middle::stability::AllowUnstable;
+use rustc_middle::mir::interpret::{LitToConstError, LitToConstInput};
 use rustc_middle::ty::subst::{self, GenericArgKind, InternalSubsts, SubstsRef};
 use rustc_middle::ty::GenericParamDefKind;
 use rustc_middle::ty::{self, Const, DefIdTree, IsSuggestable, Ty, TyCtxt, TypeVisitable};
@@ -2968,23 +2970,72 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 // handled specially and will not descend into this routine.
                 self.ty_infer(None, ast_ty.span)
             }
-            hir::TyKind::Pat(_ty, pat) => match pat.kind {
-                hir::PatKind::Wild => {
-                    let err = tcx.sess.emit_err(WildPatTy { span: pat.span });
-                    tcx.ty_error_with_guaranteed(err)
-                }
-                hir::PatKind::Binding(_, _, _, _) => todo!(),
-                hir::PatKind::Struct(_, _, _) => todo!(),
-                hir::PatKind::TupleStruct(_, _, _) => todo!(),
-                hir::PatKind::Or(_) => todo!(),
-                hir::PatKind::Path(_) => todo!(),
-                hir::PatKind::Tuple(_, _) => todo!(),
-                hir::PatKind::Box(_) => todo!(),
-                hir::PatKind::Ref(_, _) => todo!(),
-                hir::PatKind::Lit(_) => todo!(),
-                hir::PatKind::Range(_, _, _) => tcx.ty_error(),
-                hir::PatKind::Slice(_, _, _) => todo!(),
-            },
+            hir::TyKind::Pat(ty, pat) => {
+                let ty = self.ast_ty_to_ty(ty);
+                let pat_ty = match pat.kind {
+                    hir::PatKind::Wild => {
+                        let err = tcx.sess.emit_err(WildPatTy { span: pat.span });
+                        tcx.ty_error_with_guaranteed(err)
+                    }
+                    hir::PatKind::Binding(_, _, _, _) => todo!(),
+                    hir::PatKind::Struct(_, _, _) => todo!(),
+                    hir::PatKind::TupleStruct(_, _, _) => todo!(),
+                    hir::PatKind::Or(_) => todo!(),
+                    hir::PatKind::Path(_) => todo!(),
+                    hir::PatKind::Tuple(_, _) => todo!(),
+                    hir::PatKind::Box(_) => todo!(),
+                    hir::PatKind::Ref(_, _) => todo!(),
+                    hir::PatKind::Lit(_) => todo!(),
+                    hir::PatKind::Range(start, end, include_end) => {
+                        let expr_to_const = |expr: &'tcx hir::Expr<'tcx>, neg| -> ty::Const<'tcx> {
+                            match &expr.kind {
+                                hir::ExprKind::Lit(lit) => {
+                                    let lit_input = LitToConstInput { lit: &lit.node, ty, neg };
+                                    match tcx.lit_to_const(lit_input) {
+                                        Ok(c) => c,
+                                        Err(LitToConstError::Reported(err)) => {
+                                            tcx.const_error_with_guaranteed(ty, err)
+                                        }
+                                        Err(LitToConstError::TypeError) => todo!(),
+                                    }
+                                }
+                                _ => {
+                                    let err = tcx.sess.emit_err(NonConstRange { span: expr.span });
+                                    tcx.const_error_with_guaranteed(ty, err)
+                                }
+                            }
+                        };
+                        let expr_to_const = |expr, neg| {
+                            let c = expr_to_const(expr, neg);
+                            self.record_ty(expr.hir_id, c.ty(), expr.span);
+                            c
+                        };
+                        let expr_to_const = |expr: &'tcx hir::Expr<'tcx>| match &expr.kind {
+                            hir::ExprKind::Unary(hir::UnOp::Neg, expr) => expr_to_const(expr, true),
+                            _ => expr_to_const(expr, false),
+                        };
+                        let expr_to_const = |expr| {
+                            let c = expr_to_const(expr);
+                            self.record_ty(expr.hir_id, c.ty(), expr.span);
+                            c
+                        };
+
+                        let start = start.map(expr_to_const);
+                        let end = end.map(expr_to_const);
+
+                        let include_end = match include_end {
+                            hir::RangeEnd::Included => true,
+                            hir::RangeEnd::Excluded => false,
+                        };
+
+                        let pat = tcx.mk_pat(ty::PatternKind::Range { start, end, include_end });
+                        tcx.mk_ty(ty::Pat(ty, pat))
+                    }
+                    hir::PatKind::Slice(_, _, _) => todo!(),
+                };
+                self.record_ty(pat.hir_id, ty, pat.span);
+                pat_ty
+            }
             hir::TyKind::Err => tcx.ty_error(),
         };
 

compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs

@@ -208,6 +208,9 @@ impl<'tcx> InherentCollect<'tcx> {
                 .note("define and implement a new trait or type instead")
                 .emit();
             }
+            ty::Pat(..) => {
+                self.tcx.sess.span_err(ty.span, "cannot define inherent `impl` for pattern types");
+            }
             ty::Bool
             | ty::Char
             | ty::Int(_)

compiler/rustc_hir_analysis/src/errors/pattern_types.rs

@@ -7,3 +7,10 @@ pub struct WildPatTy {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(hir_analysis_pattern_type_non_const_range)]
+pub struct NonConstRange {
+    #[primary_span]
+    pub span: Span,
+}