add WellFormedConst predicate

Author: lcnr

src/librustc_infer/infer/outlives/mod.rs

@@ -20,7 +20,8 @@ pub fn explicit_outlives_bounds<'tcx>(
         | ty::PredicateKind::ClosureKind(..)
         | ty::PredicateKind::TypeOutlives(..)
         | ty::PredicateKind::ConstEvaluatable(..)
-        | ty::PredicateKind::ConstEquate(..) => None,
+        | ty::PredicateKind::ConstEquate(..)
+        | ty::PredicateKind::WellFormedConst(..) => None,
         ty::PredicateKind::RegionOutlives(ref data) => data
             .no_bound_vars()
             .map(|ty::OutlivesPredicate(r_a, r_b)| OutlivesBound::RegionSubRegion(r_b, r_a)),

src/librustc_infer/traits/util.rs

@@ -45,6 +45,8 @@ pub fn anonymize_predicate<'tcx>(
         }
 
         ty::PredicateKind::ConstEquate(c1, c2) => ty::PredicateKind::ConstEquate(c1, c2),
+
+        ty::PredicateKind::WellFormedConst(ct) => ty::PredicateKind::WellFormedConst(ct),
     };
 
     if new != *kind { new.to_predicate(tcx) } else { pred }
@@ -204,6 +206,9 @@ impl Elaborator<'tcx> {
                 // Currently, we do not elaborate const-equate
                 // predicates.
             }
+            ty::PredicateKind::WellFormedConst(..) => {
+                // Currently, we do not elaborate WF predicates.
+            }
             ty::PredicateKind::RegionOutlives(..) => {
                 // Nothing to elaborate from `'a: 'b`.
             }

src/librustc_lint/builtin.rs

@@ -1218,6 +1218,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TrivialConstraints {
                     Projection(..) |
                     // Ignore bounds that a user can't type
                     WellFormed(..) |
+                    WellFormedConst(..) |
                     ObjectSafe(..) |
                     ClosureKind(..) |
                     Subtype(..) |

src/librustc_middle/ty/mod.rs

@@ -1079,6 +1079,9 @@ pub enum PredicateKind<'tcx> {
 
     /// Constants must be equal. The first component is the const that is expected.
     ConstEquate(&'tcx Const<'tcx>, &'tcx Const<'tcx>),
+
+    /// Constant must be well formed.
+    WellFormedConst(&'tcx Const<'tcx>),
 }
 
 /// The crate outlives map is computed during typeck and contains the
@@ -1195,6 +1198,9 @@ impl<'tcx> Predicate<'tcx> {
             PredicateKind::ConstEquate(c1, c2) => {
                 PredicateKind::ConstEquate(c1.subst(tcx, substs), c2.subst(tcx, substs))
             }
+            PredicateKind::WellFormedConst(c) => {
+                PredicateKind::WellFormedConst(c.subst(tcx, substs))
+            }
         };
 
         if new != *kind { new.to_predicate(tcx) } else { self }
@@ -1386,7 +1392,8 @@ impl<'tcx> Predicate<'tcx> {
             | PredicateKind::ClosureKind(..)
             | PredicateKind::TypeOutlives(..)
             | PredicateKind::ConstEvaluatable(..)
-            | PredicateKind::ConstEquate(..) => None,
+            | PredicateKind::ConstEquate(..)
+            | PredicateKind::WellFormedConst(..) => None,
         }
     }
 
@@ -1401,7 +1408,8 @@ impl<'tcx> Predicate<'tcx> {
             | PredicateKind::ObjectSafe(..)
             | PredicateKind::ClosureKind(..)
             | PredicateKind::ConstEvaluatable(..)
-            | PredicateKind::ConstEquate(..) => None,
+            | PredicateKind::ConstEquate(..)
+            | PredicateKind::WellFormedConst(..) => None,
         }
     }
 }

src/librustc_middle/ty/print/pretty.rs

@@ -2054,6 +2054,9 @@ define_print_and_forward_display! {
                    print(c2),
                    write("`"))
             }
+            ty::PredicateKind::WellFormedConst(c) => {
+                p!(print(c), write(" well-formed"))
+            }
         }
     }
 

src/librustc_middle/ty/structural_impls.rs

@@ -247,6 +247,7 @@ impl fmt::Debug for ty::PredicateKind<'tcx> {
                 write!(f, "ConstEvaluatable({:?}, {:?})", def_id, substs)
             }
             ty::PredicateKind::ConstEquate(c1, c2) => write!(f, "ConstEquate({:?}, {:?})", c1, c2),
+            ty::PredicateKind::WellFormedConst(c) => write!(f, "WellFormedConst({:?})", c),
         }
     }
 }
@@ -507,6 +508,9 @@ impl<'a, 'tcx> Lift<'tcx> for ty::PredicateKind<'a> {
             ty::PredicateKind::ConstEquate(c1, c2) => {
                 tcx.lift(&(c1, c2)).map(|(c1, c2)| ty::PredicateKind::ConstEquate(c1, c2))
             }
+            ty::PredicateKind::WellFormedConst(c) => {
+                tcx.lift(&c).map(ty::PredicateKind::WellFormedConst)
+            }
         }
     }
 }

src/librustc_mir/transform/qualify_min_const_fn.rs

@@ -29,7 +29,8 @@ pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, def_id: DefId, body: &'a Body<'tcx>) -
                 | ty::PredicateKind::WellFormed(_)
                 | ty::PredicateKind::Projection(_)
                 | ty::PredicateKind::ConstEvaluatable(..)
-                | ty::PredicateKind::ConstEquate(..) => continue,
+                | ty::PredicateKind::ConstEquate(..)
+                | ty::PredicateKind::WellFormedConst(..) => continue,
                 ty::PredicateKind::ObjectSafe(_) => {
                     bug!("object safe predicate on function: {:#?}", predicate)
                 }

src/librustc_trait_selection/opaque_types.rs

@@ -1277,7 +1277,8 @@ crate fn required_region_bounds(
                 | ty::PredicateKind::ClosureKind(..)
                 | ty::PredicateKind::RegionOutlives(..)
                 | ty::PredicateKind::ConstEvaluatable(..)
-                | ty::PredicateKind::ConstEquate(..) => None,
+                | ty::PredicateKind::ConstEquate(..)
+                | ty::PredicateKind::WellFormedConst(..) => None,
                 ty::PredicateKind::TypeOutlives(predicate) => {
                     // Search for a bound of the form `erased_self_ty
                     // : 'a`, but be wary of something like `for<'a>

src/librustc_trait_selection/traits/error_reporting/mod.rs

@@ -610,6 +610,15 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                         }
                     }
 
+                    ty::PredicateKind::WellFormedConst(ct) => {
+                        // Const WF predicates cannot themselves make
+                        // errors. They can only block due to
+                        // ambiguity; otherwise, they always
+                        // degenerate into other obligations
+                        // (which may fail).
+                        span_bug!(span, "const WF predicate not satisfied for {:?}", ct);
+                    }
+
                     ty::PredicateKind::ConstEvaluatable(..) => {
                         // Errors for `ConstEvaluatable` predicates show up as
                         // `SelectionError::ConstEvalFailure`,
@@ -1540,6 +1549,15 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
                 self.need_type_info_err(body_id, span, ty, ErrorCode::E0282)
             }
 
+            ty::PredicateKind::WellFormedConst(ct) => {
+                // Same hacky approach as above to avoid deluging user
+                // with error messages.
+                if ct.references_error() || self.tcx.sess.has_errors() {
+                    return;
+                }
+                self.need_type_info_err_const(body_id, span, ct, ErrorCode::E0282)
+            }
+
             ty::PredicateKind::Subtype(ref data) => {
                 if data.references_error() || self.tcx.sess.has_errors() {
                     // no need to overload user in such cases

src/librustc_trait_selection/traits/fulfill.rs

@@ -476,6 +476,21 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
                 }
             }
 
+            ty::PredicateKind::WellFormedConst(constant) => match wf::const_obligations(
+                self.selcx.infcx(),
+                obligation.param_env,
+                obligation.cause.body_id,
+                constant,
+                obligation.cause.span,
+            ) {
+                Some(predicates) => ProcessResult::Changed(mk_pending(predicates)),
+                None => {
+                    pending_obligation.stalled_on =
+                        vec![TyOrConstInferVar::maybe_from_const(constant).unwrap()];
+                    ProcessResult::Unchanged
+                }
+            },
+
             &ty::PredicateKind::Subtype(subtype) => {
                 match self.selcx.infcx().subtype_predicate(
                     &obligation.cause,