compiler/rustc_trait_selection/src/traits/const_evaluatable.rs

   1 //! Checking that constant values used in types can be successfully evaluated.
   2 //!
   3 //! For concrete constants, this is fairly simple as we can just try and evaluate it.
   4 //!
   5 //! When dealing with polymorphic constants, for example `std::mem::size_of::<T>() - 1`,
   6 //! this is not as easy.
   7 //!
   8 //! In this case we try to build an abstract representation of this constant using
   9 //! `thir_abstract_const` which can then be checked for structural equality with other
  10 //! generic constants mentioned in the `caller_bounds` of the current environment.
  11 use rustc_data_structures::intern::Interned;
  12 use rustc_errors::ErrorGuaranteed;
  13 use rustc_hir::def::DefKind;
  14 use rustc_index::vec::IndexVec;
  15 use rustc_infer::infer::InferCtxt;
  16 use rustc_middle::mir;
  17 use rustc_middle::mir::interpret::{
  18     ConstValue, ErrorHandled, LitToConstError, LitToConstInput, Scalar,
  19 };
  20 use rustc_middle::thir;
  21 use rustc_middle::thir::abstract_const::{self, Node, NodeId, NotConstEvaluatable};
  22 use rustc_middle::ty::subst::{Subst, SubstsRef};
  23 use rustc_middle::ty::{self, DelaySpanBugEmitted, TyCtxt, TypeFoldable};
  24 use rustc_session::lint;
  25 use rustc_span::def_id::LocalDefId;
  26 use rustc_span::Span;
  27
  28 use std::cmp;
  29 use std::iter;
  30 use std::ops::ControlFlow;
  31
  32 /// Check if a given constant can be evaluated.
  33 #[instrument(skip(infcx), level = "debug")]
  34 pub fn is_const_evaluatable<'cx, 'tcx>(
  35     infcx: &InferCtxt<'cx, 'tcx>,
  36     uv: ty::Unevaluated<'tcx, ()>,
  37     param_env: ty::ParamEnv<'tcx>,
  38     span: Span,
  39 ) -> Result<(), NotConstEvaluatable> {
  40     let tcx = infcx.tcx;
  41
  42     if tcx.features().generic_const_exprs {
  43         match AbstractConst::new(tcx, uv)? {
  44             // We are looking at a generic abstract constant.
  45             Some(ct) => {
  46                 if satisfied_from_param_env(tcx, ct, param_env)? {
  47                     return Ok(());
  48                 }
  49
  50                 // We were unable to unify the abstract constant with
  51                 // a constant found in the caller bounds, there are
  52                 // now three possible cases here.
  53                 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
  54                 enum FailureKind {
  55                     /// The abstract const still references an inference
  56                     /// variable, in this case we return `TooGeneric`.
  57                     MentionsInfer,
  58                     /// The abstract const references a generic parameter,
  59                     /// this means that we emit an error here.
  60                     MentionsParam,
  61                     /// The substs are concrete enough that we can simply
  62                     /// try and evaluate the given constant.
  63                     Concrete,
  64                 }
  65                 let mut failure_kind = FailureKind::Concrete;
  66                 walk_abstract_const::<!, _>(tcx, ct, |node| match node.root(tcx) {
  67                     Node::Leaf(leaf) => {
  68                         if leaf.has_infer_types_or_consts() {
  69                             failure_kind = FailureKind::MentionsInfer;
  70                         } else if leaf.has_param_types_or_consts() {
  71                             failure_kind = cmp::min(failure_kind, FailureKind::MentionsParam);
  72                         }
  73
  74                         ControlFlow::CONTINUE
  75                     }
  76                     Node::Cast(_, _, ty) => {
  77                         if ty.has_infer_types_or_consts() {
  78                             failure_kind = FailureKind::MentionsInfer;
  79                         } else if ty.has_param_types_or_consts() {
  80                             failure_kind = cmp::min(failure_kind, FailureKind::MentionsParam);
  81                         }
  82
  83                         ControlFlow::CONTINUE
  84                     }
  85                     Node::Binop(_, _, _) | Node::UnaryOp(_, _) | Node::FunctionCall(_, _) => {
  86                         ControlFlow::CONTINUE
  87                     }
  88                 });
  89
  90                 match failure_kind {
  91                     FailureKind::MentionsInfer => {
  92                         return Err(NotConstEvaluatable::MentionsInfer);
  93                     }
  94                     FailureKind::MentionsParam => {
  95                         return Err(NotConstEvaluatable::MentionsParam);
  96                     }
  97                     FailureKind::Concrete => {
  98                         // Dealt with below by the same code which handles this
  99                         // without the feature gate.
 100                     }
 101                 }
 102             }
 103             None => {
 104                 // If we are dealing with a concrete constant, we can
 105                 // reuse the old code path and try to evaluate
 106                 // the constant.
 107             }
 108         }
 109     }
 110
 111     let future_compat_lint = || {
 112         if let Some(local_def_id) = uv.def.did.as_local() {
 113             infcx.tcx.struct_span_lint_hir(
 114                 lint::builtin::CONST_EVALUATABLE_UNCHECKED,
 115                 infcx.tcx.hir().local_def_id_to_hir_id(local_def_id),
 116                 span,
 117                 |err| {
 118                     err.build("cannot use constants which depend on generic parameters in types")
 119                         .emit();
 120                 },
 121             );
 122         }
 123     };
 124
 125     // FIXME: We should only try to evaluate a given constant here if it is fully concrete
 126     // as we don't want to allow things like `[u8; std::mem::size_of::<*mut T>()]`.
 127     //
 128     // We previously did not check this, so we only emit a future compat warning if
 129     // const evaluation succeeds and the given constant is still polymorphic for now
 130     // and hopefully soon change this to an error.
 131     //
 132     // See #74595 for more details about this.
 133     let concrete = infcx.const_eval_resolve(param_env, uv.expand(), Some(span));
 134
 135     if concrete.is_ok() && uv.substs.has_param_types_or_consts() {
 136         match infcx.tcx.def_kind(uv.def.did) {
 137             DefKind::AnonConst | DefKind::InlineConst => {
 138                 let mir_body = infcx.tcx.mir_for_ctfe_opt_const_arg(uv.def);
 139
 140                 if mir_body.is_polymorphic {
 141                     future_compat_lint();
 142                 }
 143             }
 144             _ => future_compat_lint(),
 145         }
 146     }
 147
 148     // If we're evaluating a foreign constant, under a nightly compiler without generic
 149     // const exprs, AND it would've passed if that expression had been evaluated with
 150     // generic const exprs, then suggest using generic const exprs.
 151     if concrete.is_err()
 152         && tcx.sess.is_nightly_build()
 153         && !uv.def.did.is_local()
 154         && !tcx.features().generic_const_exprs
 155         && let Ok(Some(ct)) = AbstractConst::new(tcx, uv)
 156         && satisfied_from_param_env(tcx, ct, param_env) == Ok(true)
 157     {
 158         tcx.sess
 159             .struct_span_fatal(
 160                 // Slightly better span than just using `span` alone
 161                 if span == rustc_span::DUMMY_SP { tcx.def_span(uv.def.did) } else { span },
 162                 "failed to evaluate generic const expression",
 163             )
 164             .note("the crate this constant originates from uses `#![feature(generic_const_exprs)]`")
 165             .span_suggestion_verbose(
 166                 rustc_span::DUMMY_SP,
 167                 "consider enabling this feature",
 168                 "#![feature(generic_const_exprs)]\n".to_string(),
 169                 rustc_errors::Applicability::MaybeIncorrect,
 170             )
 171             .emit()
 172     }
 173
 174     debug!(?concrete, "is_const_evaluatable");
 175     match concrete {
 176         Err(ErrorHandled::TooGeneric) => Err(match uv.has_infer_types_or_consts() {
 177             true => NotConstEvaluatable::MentionsInfer,
 178             false => NotConstEvaluatable::MentionsParam,
 179         }),
 180         Err(ErrorHandled::Linted) => {
 181             let reported =
 182                 infcx.tcx.sess.delay_span_bug(span, "constant in type had error reported as lint");
 183             Err(NotConstEvaluatable::Error(reported))
 184         }
 185         Err(ErrorHandled::Reported(e)) => Err(NotConstEvaluatable::Error(e)),
 186         Ok(_) => Ok(()),
 187     }
 188 }
 189
 190 #[instrument(skip(tcx), level = "debug")]
 191 fn satisfied_from_param_env<'tcx>(
 192     tcx: TyCtxt<'tcx>,
 193     ct: AbstractConst<'tcx>,
 194     param_env: ty::ParamEnv<'tcx>,
 195 ) -> Result<bool, NotConstEvaluatable> {
 196     for pred in param_env.caller_bounds() {
 197         match pred.kind().skip_binder() {
 198             ty::PredicateKind::ConstEvaluatable(uv) => {
 199                 if let Some(b_ct) = AbstractConst::new(tcx, uv)? {
 200                     let const_unify_ctxt = ConstUnifyCtxt { tcx, param_env };
 201
 202                     // Try to unify with each subtree in the AbstractConst to allow for
 203                     // `N + 1` being const evaluatable even if theres only a `ConstEvaluatable`
 204                     // predicate for `(N + 1) * 2`
 205                     let result = walk_abstract_const(tcx, b_ct, |b_ct| {
 206                         match const_unify_ctxt.try_unify(ct, b_ct) {
 207                             true => ControlFlow::BREAK,
 208                             false => ControlFlow::CONTINUE,
 209                         }
 210                     });
 211
 212                     if let ControlFlow::Break(()) = result {
 213                         debug!("is_const_evaluatable: abstract_const ~~> ok");
 214                         return Ok(true);
 215                     }
 216                 }
 217             }
 218             _ => {} // don't care
 219         }
 220     }
 221
 222     Ok(false)
 223 }
 224
 225 /// A tree representing an anonymous constant.
 226 ///
 227 /// This is only able to represent a subset of `MIR`,
 228 /// and should not leak any information about desugarings.
 229 #[derive(Debug, Clone, Copy)]
 230 pub struct AbstractConst<'tcx> {
 231     // FIXME: Consider adding something like `IndexSlice`
 232     // and use this here.
 233     inner: &'tcx [Node<'tcx>],
 234     substs: SubstsRef<'tcx>,
 235 }
 236
 237 impl<'tcx> AbstractConst<'tcx> {
 238     pub fn new(
 239         tcx: TyCtxt<'tcx>,
 240         uv: ty::Unevaluated<'tcx, ()>,
 241     ) -> Result<Option<AbstractConst<'tcx>>, ErrorGuaranteed> {
 242         let inner = tcx.thir_abstract_const_opt_const_arg(uv.def)?;
 243         debug!("AbstractConst::new({:?}) = {:?}", uv, inner);
 244         Ok(inner.map(|inner| AbstractConst { inner, substs: uv.substs }))
 245     }
 246
 247     pub fn from_const(
 248         tcx: TyCtxt<'tcx>,
 249         ct: ty::Const<'tcx>,
 250     ) -> Result<Option<AbstractConst<'tcx>>, ErrorGuaranteed> {
 251         match ct.val() {
 252             ty::ConstKind::Unevaluated(uv) => AbstractConst::new(tcx, uv.shrink()),
 253             ty::ConstKind::Error(DelaySpanBugEmitted { reported, .. }) => Err(reported),
 254             _ => Ok(None),
 255         }
 256     }
 257
 258     #[inline]
 259     pub fn subtree(self, node: NodeId) -> AbstractConst<'tcx> {
 260         AbstractConst { inner: &self.inner[..=node.index()], substs: self.substs }
 261     }
 262
 263     #[inline]
 264     pub fn root(self, tcx: TyCtxt<'tcx>) -> Node<'tcx> {
 265         let node = self.inner.last().copied().unwrap();
 266         match node {
 267             Node::Leaf(leaf) => Node::Leaf(leaf.subst(tcx, self.substs)),
 268             Node::Cast(kind, operand, ty) => Node::Cast(kind, operand, ty.subst(tcx, self.substs)),
 269             // Don't perform substitution on the following as they can't directly contain generic params
 270             Node::Binop(_, _, _) | Node::UnaryOp(_, _) | Node::FunctionCall(_, _) => node,
 271         }
 272     }
 273 }
 274
 275 struct AbstractConstBuilder<'a, 'tcx> {
 276     tcx: TyCtxt<'tcx>,
 277     body_id: thir::ExprId,
 278     body: &'a thir::Thir<'tcx>,
 279     /// The current WIP node tree.
 280     nodes: IndexVec<NodeId, Node<'tcx>>,
 281 }
 282
 283 impl<'a, 'tcx> AbstractConstBuilder<'a, 'tcx> {
 284     fn root_span(&self) -> Span {
 285         self.body.exprs[self.body_id].span
 286     }
 287
 288     fn error(&mut self, span: Span, msg: &str) -> Result<!, ErrorGuaranteed> {
 289         let reported = self
 290             .tcx
 291             .sess
 292             .struct_span_err(self.root_span(), "overly complex generic constant")
 293             .span_label(span, msg)
 294             .help("consider moving this anonymous constant into a `const` function")
 295             .emit();
 296
 297         Err(reported)
 298     }
 299     fn maybe_supported_error(&mut self, span: Span, msg: &str) -> Result<!, ErrorGuaranteed> {
 300         let reported = self
 301             .tcx
 302             .sess
 303             .struct_span_err(self.root_span(), "overly complex generic constant")
 304             .span_label(span, msg)
 305             .help("consider moving this anonymous constant into a `const` function")
 306             .note("this operation may be supported in the future")
 307             .emit();
 308
 309         Err(reported)
 310     }
 311
 312     #[instrument(skip(tcx, body, body_id), level = "debug")]
 313     fn new(
 314         tcx: TyCtxt<'tcx>,
 315         (body, body_id): (&'a thir::Thir<'tcx>, thir::ExprId),
 316     ) -> Result<Option<AbstractConstBuilder<'a, 'tcx>>, ErrorGuaranteed> {
 317         let builder = AbstractConstBuilder { tcx, body_id, body, nodes: IndexVec::new() };
 318
 319         struct IsThirPolymorphic<'a, 'tcx> {
 320             is_poly: bool,
 321             thir: &'a thir::Thir<'tcx>,
 322         }
 323
 324         use crate::rustc_middle::thir::visit::Visitor;
 325         use thir::visit;
 326
 327         impl<'a, 'tcx> IsThirPolymorphic<'a, 'tcx> {
 328             fn expr_is_poly(&mut self, expr: &thir::Expr<'tcx>) -> bool {
 329                 if expr.ty.has_param_types_or_consts() {
 330                     return true;
 331                 }
 332
 333                 match expr.kind {
 334                     thir::ExprKind::NamedConst { substs, .. } => substs.has_param_types_or_consts(),
 335                     thir::ExprKind::ConstParam { .. } => true,
 336                     thir::ExprKind::Repeat { value, count } => {
 337                         self.visit_expr(&self.thir()[value]);
 338                         count.has_param_types_or_consts()
 339                     }
 340                     _ => false,
 341                 }
 342             }
 343
 344             fn pat_is_poly(&mut self, pat: &thir::Pat<'tcx>) -> bool {
 345                 if pat.ty.has_param_types_or_consts() {
 346                     return true;
 347                 }
 348
 349                 match pat.kind.as_ref() {
 350                     thir::PatKind::Constant { value } => value.has_param_types_or_consts(),
 351                     thir::PatKind::Range(thir::PatRange { lo, hi, .. }) => {
 352                         lo.has_param_types_or_consts() || hi.has_param_types_or_consts()
 353                     }
 354                     _ => false,
 355                 }
 356             }
 357         }
 358
 359         impl<'a, 'tcx> visit::Visitor<'a, 'tcx> for IsThirPolymorphic<'a, 'tcx> {
 360             fn thir(&self) -> &'a thir::Thir<'tcx> {
 361                 &self.thir
 362             }
 363
 364             #[instrument(skip(self), level = "debug")]
 365             fn visit_expr(&mut self, expr: &thir::Expr<'tcx>) {
 366                 self.is_poly |= self.expr_is_poly(expr);
 367                 if !self.is_poly {
 368                     visit::walk_expr(self, expr)
 369                 }
 370             }
 371
 372             #[instrument(skip(self), level = "debug")]
 373             fn visit_pat(&mut self, pat: &thir::Pat<'tcx>) {
 374                 self.is_poly |= self.pat_is_poly(pat);
 375                 if !self.is_poly {
 376                     visit::walk_pat(self, pat);
 377                 }
 378             }
 379
 380             fn visit_const(&mut self, ct: ty::Const<'tcx>) {
 381                 self.is_poly |= ct.has_param_types_or_consts();
 382             }
 383
 384             fn visit_constant(&mut self, ct: mir::ConstantKind<'tcx>) {
 385                 self.is_poly |= ct.has_param_types_or_consts();
 386             }
 387         }
 388
 389         let mut is_poly_vis = IsThirPolymorphic { is_poly: false, thir: body };
 390         visit::walk_expr(&mut is_poly_vis, &body[body_id]);
 391         debug!("AbstractConstBuilder: is_poly={}", is_poly_vis.is_poly);
 392         if !is_poly_vis.is_poly {
 393             return Ok(None);
 394         }
 395
 396         Ok(Some(builder))
 397     }
 398
 399     /// We do not allow all binary operations in abstract consts, so filter disallowed ones.
 400     fn check_binop(op: mir::BinOp) -> bool {
 401         use mir::BinOp::*;
 402         match op {
 403             Add | Sub | Mul | Div | Rem | BitXor | BitAnd | BitOr | Shl | Shr | Eq | Lt | Le
 404             | Ne | Ge | Gt => true,
 405             Offset => false,
 406         }
 407     }
 408
 409     /// While we currently allow all unary operations, we still want to explicitly guard against
 410     /// future changes here.
 411     fn check_unop(op: mir::UnOp) -> bool {
 412         use mir::UnOp::*;
 413         match op {
 414             Not | Neg => true,
 415         }
 416     }
 417
 418     /// Builds the abstract const by walking the thir and bailing out when
 419     /// encountering an unsupported operation.
 420     fn build(mut self) -> Result<&'tcx [Node<'tcx>], ErrorGuaranteed> {
 421         debug!("Abstractconstbuilder::build: body={:?}", &*self.body);
 422         self.recurse_build(self.body_id)?;
 423
 424         for n in self.nodes.iter() {
 425             if let Node::Leaf(ty::Const(Interned(
 426                 ty::ConstS { val: ty::ConstKind::Unevaluated(ct), ty: _ },
 427                 _,
 428             ))) = n
 429             {
 430                 // `AbstractConst`s should not contain any promoteds as they require references which
 431                 // are not allowed.
 432                 assert_eq!(ct.promoted, None);
 433             }
 434         }
 435
 436         Ok(self.tcx.arena.alloc_from_iter(self.nodes.into_iter()))
 437     }
 438
 439     fn recurse_build(&mut self, node: thir::ExprId) -> Result<NodeId, ErrorGuaranteed> {
 440         use thir::ExprKind;
 441         let node = &self.body.exprs[node];
 442         Ok(match &node.kind {
 443             // I dont know if handling of these 3 is correct
 444             &ExprKind::Scope { value, .. } => self.recurse_build(value)?,
 445             &ExprKind::PlaceTypeAscription { source, .. }
 446             | &ExprKind::ValueTypeAscription { source, .. } => self.recurse_build(source)?,
 447             &ExprKind::Literal { lit, neg} => {
 448                 let sp = node.span;
 449                 let constant =
 450                     match self.tcx.at(sp).lit_to_const(LitToConstInput { lit: &lit.node, ty: node.ty, neg }) {
 451                         Ok(c) => c,
 452                         Err(LitToConstError::Reported) => {
 453                             self.tcx.const_error(node.ty)
 454                         }
 455                         Err(LitToConstError::TypeError) => {
 456                             bug!("encountered type error in lit_to_const")
 457                         }
 458                     };
 459
 460                 self.nodes.push(Node::Leaf(constant))
 461             }
 462             &ExprKind::NonHirLiteral { lit , user_ty: _} => {
 463                 // FIXME Construct a Valtree from this ScalarInt when introducing Valtrees
 464                 let const_value = ConstValue::Scalar(Scalar::Int(lit));
 465                 self.nodes.push(Node::Leaf(ty::Const::from_value(self.tcx, const_value, node.ty)))
 466             }
 467             &ExprKind::NamedConst { def_id, substs, user_ty: _ } => {
 468                 let uneval = ty::Unevaluated::new(ty::WithOptConstParam::unknown(def_id), substs);
 469
 470                 let constant = self.tcx.mk_const(ty::ConstS {
 471                                 val: ty::ConstKind::Unevaluated(uneval),
 472                                 ty: node.ty,
 473                             });
 474
 475                 self.nodes.push(Node::Leaf(constant))
 476             }
 477
 478             ExprKind::ConstParam {param, ..} => {
 479                 let const_param = self.tcx.mk_const(ty::ConstS {
 480                         val: ty::ConstKind::Param(*param),
 481                         ty: node.ty,
 482                     });
 483                 self.nodes.push(Node::Leaf(const_param))
 484             }
 485
 486             ExprKind::Call { fun, args, .. } => {
 487                 let fun = self.recurse_build(*fun)?;
 488
 489                 let mut new_args = Vec::<NodeId>::with_capacity(args.len());
 490                 for &id in args.iter() {
 491                     new_args.push(self.recurse_build(id)?);
 492                 }
 493                 let new_args = self.tcx.arena.alloc_slice(&new_args);
 494                 self.nodes.push(Node::FunctionCall(fun, new_args))
 495             }
 496             &ExprKind::Binary { op, lhs, rhs } if Self::check_binop(op) => {
 497                 let lhs = self.recurse_build(lhs)?;
 498                 let rhs = self.recurse_build(rhs)?;
 499                 self.nodes.push(Node::Binop(op, lhs, rhs))
 500             }
 501             &ExprKind::Unary { op, arg } if Self::check_unop(op) => {
 502                 let arg = self.recurse_build(arg)?;
 503                 self.nodes.push(Node::UnaryOp(op, arg))
 504             }
 505             // This is necessary so that the following compiles:
 506             //
 507             // ```
 508             // fn foo<const N: usize>(a: [(); N + 1]) {
 509             //     bar::<{ N + 1 }>();
 510             // }
 511             // ```
 512             ExprKind::Block { body: thir::Block { stmts: box [], expr: Some(e), .. } } => {
 513                 self.recurse_build(*e)?
 514             }
 515             // `ExprKind::Use` happens when a `hir::ExprKind::Cast` is a
 516             // "coercion cast" i.e. using a coercion or is a no-op.
 517             // This is important so that `N as usize as usize` doesnt unify with `N as usize`. (untested)
 518             &ExprKind::Use { source } => {
 519                 let arg = self.recurse_build(source)?;
 520                 self.nodes.push(Node::Cast(abstract_const::CastKind::Use, arg, node.ty))
 521             }
 522             &ExprKind::Cast { source } => {
 523                 let arg = self.recurse_build(source)?;
 524                 self.nodes.push(Node::Cast(abstract_const::CastKind::As, arg, node.ty))
 525             }
 526             ExprKind::Borrow{ arg, ..} => {
 527                 let arg_node = &self.body.exprs[*arg];
 528
 529                 // Skip reborrows for now until we allow Deref/Borrow/AddressOf
 530                 // expressions.
 531                 // FIXME(generic_const_exprs): Verify/explain why this is sound
 532                 if let ExprKind::Deref {arg} = arg_node.kind {
 533                     self.recurse_build(arg)?
 534                 } else {
 535                     self.maybe_supported_error(
 536                         node.span,
 537                         "borrowing is not supported in generic constants",
 538                     )?
 539                 }
 540             }
 541             // FIXME(generic_const_exprs): We may want to support these.
 542             ExprKind::AddressOf { .. } | ExprKind::Deref {..}=> self.maybe_supported_error(
 543                 node.span,
 544                 "dereferencing or taking the address is not supported in generic constants",
 545             )?,
 546             ExprKind::Repeat { .. } | ExprKind::Array { .. } =>  self.maybe_supported_error(
 547                 node.span,
 548                 "array construction is not supported in generic constants",
 549             )?,
 550             ExprKind::Block { .. } => self.maybe_supported_error(
 551                 node.span,
 552                 "blocks are not supported in generic constant",
 553             )?,
 554             ExprKind::NeverToAny { .. } => self.maybe_supported_error(
 555                 node.span,
 556                 "converting nevers to any is not supported in generic constant",
 557             )?,
 558             ExprKind::Tuple { .. } => self.maybe_supported_error(
 559                 node.span,
 560                 "tuple construction is not supported in generic constants",
 561             )?,
 562             ExprKind::Index { .. } => self.maybe_supported_error(
 563                 node.span,
 564                 "indexing is not supported in generic constant",
 565             )?,
 566             ExprKind::Field { .. } => self.maybe_supported_error(
 567                 node.span,
 568                 "field access is not supported in generic constant",
 569             )?,
 570             ExprKind::ConstBlock { .. } => self.maybe_supported_error(
 571                 node.span,
 572                 "const blocks are not supported in generic constant",
 573             )?,
 574             ExprKind::Adt(_) => self.maybe_supported_error(
 575                 node.span,
 576                 "struct/enum construction is not supported in generic constants",
 577             )?,
 578             // dont know if this is correct
 579             ExprKind::Pointer { .. } =>
 580                 self.error(node.span, "pointer casts are not allowed in generic constants")?,
 581             ExprKind::Yield { .. } =>
 582                 self.error(node.span, "generator control flow is not allowed in generic constants")?,
 583             ExprKind::Continue { .. } | ExprKind::Break { .. } | ExprKind::Loop { .. } => self
 584                 .error(
 585                     node.span,
 586                     "loops and loop control flow are not supported in generic constants",
 587                 )?,
 588             ExprKind::Box { .. } =>
 589                 self.error(node.span, "allocations are not allowed in generic constants")?,
 590
 591             ExprKind::Unary { .. } => unreachable!(),
 592             // we handle valid unary/binary ops above
 593             ExprKind::Binary { .. } =>
 594                 self.error(node.span, "unsupported binary operation in generic constants")?,
 595             ExprKind::LogicalOp { .. } =>
 596                 self.error(node.span, "unsupported operation in generic constants, short-circuiting operations would imply control flow")?,
 597             ExprKind::Assign { .. } | ExprKind::AssignOp { .. } => {
 598                 self.error(node.span, "assignment is not supported in generic constants")?
 599             }
 600             ExprKind::Closure { .. } | ExprKind::Return { .. } => self.error(
 601                 node.span,
 602                 "closures and function keywords are not supported in generic constants",
 603             )?,
 604             // let expressions imply control flow
 605             ExprKind::Match { .. } | ExprKind::If { .. } | ExprKind::Let { .. } =>
 606                 self.error(node.span, "control flow is not supported in generic constants")?,
 607             ExprKind::InlineAsm { .. } => {
 608                 self.error(node.span, "assembly is not supported in generic constants")?
 609             }
 610
 611             // we dont permit let stmts so `VarRef` and `UpvarRef` cant happen
 612             ExprKind::VarRef { .. }
 613             | ExprKind::UpvarRef { .. }
 614             | ExprKind::StaticRef { .. }
 615             | ExprKind::ThreadLocalRef(_) => {
 616                 self.error(node.span, "unsupported operation in generic constant")?
 617             }
 618         })
 619     }
 620 }
 621
 622 /// Builds an abstract const, do not use this directly, but use `AbstractConst::new` instead.
 623 pub(super) fn thir_abstract_const<'tcx>(
 624     tcx: TyCtxt<'tcx>,
 625     def: ty::WithOptConstParam<LocalDefId>,
 626 ) -> Result<Option<&'tcx [thir::abstract_const::Node<'tcx>]>, ErrorGuaranteed> {
 627     if tcx.features().generic_const_exprs {
 628         match tcx.def_kind(def.did) {
 629             // FIXME(generic_const_exprs): We currently only do this for anonymous constants,
 630             // meaning that we do not look into associated constants. I(@lcnr) am not yet sure whether
 631             // we want to look into them or treat them as opaque projections.
 632             //
 633             // Right now we do neither of that and simply always fail to unify them.
 634             DefKind::AnonConst | DefKind::InlineConst => (),
 635             _ => return Ok(None),
 636         }
 637
 638         let body = tcx.thir_body(def)?;
 639
 640         AbstractConstBuilder::new(tcx, (&*body.0.borrow(), body.1))?
 641             .map(AbstractConstBuilder::build)
 642             .transpose()
 643     } else {
 644         Ok(None)
 645     }
 646 }
 647
 648 #[instrument(skip(tcx), level = "debug")]
 649 pub(super) fn try_unify_abstract_consts<'tcx>(
 650     tcx: TyCtxt<'tcx>,
 651     (a, b): (ty::Unevaluated<'tcx, ()>, ty::Unevaluated<'tcx, ()>),
 652     param_env: ty::ParamEnv<'tcx>,
 653 ) -> bool {
 654     (|| {
 655         if let Some(a) = AbstractConst::new(tcx, a)? {
 656             if let Some(b) = AbstractConst::new(tcx, b)? {
 657                 let const_unify_ctxt = ConstUnifyCtxt { tcx, param_env };
 658                 return Ok(const_unify_ctxt.try_unify(a, b));
 659             }
 660         }
 661
 662         Ok(false)
 663     })()
 664     .unwrap_or_else(|_: ErrorGuaranteed| true)
 665     // FIXME(generic_const_exprs): We should instead have this
 666     // method return the resulting `ty::Const` and return `ConstKind::Error`
 667     // on `ErrorGuaranteed`.
 668 }
 669
 670 #[instrument(skip(tcx, f), level = "debug")]
 671 pub fn walk_abstract_const<'tcx, R, F>(
 672     tcx: TyCtxt<'tcx>,
 673     ct: AbstractConst<'tcx>,
 674     mut f: F,
 675 ) -> ControlFlow<R>
 676 where
 677     F: FnMut(AbstractConst<'tcx>) -> ControlFlow<R>,
 678 {
 679     #[instrument(skip(tcx, f), level = "debug")]
 680     fn recurse<'tcx, R>(
 681         tcx: TyCtxt<'tcx>,
 682         ct: AbstractConst<'tcx>,
 683         f: &mut dyn FnMut(AbstractConst<'tcx>) -> ControlFlow<R>,
 684     ) -> ControlFlow<R> {
 685         f(ct)?;
 686         let root = ct.root(tcx);
 687         debug!(?root);
 688         match root {
 689             Node::Leaf(_) => ControlFlow::CONTINUE,
 690             Node::Binop(_, l, r) => {
 691                 recurse(tcx, ct.subtree(l), f)?;
 692                 recurse(tcx, ct.subtree(r), f)
 693             }
 694             Node::UnaryOp(_, v) => recurse(tcx, ct.subtree(v), f),
 695             Node::FunctionCall(func, args) => {
 696                 recurse(tcx, ct.subtree(func), f)?;
 697                 args.iter().try_for_each(|&arg| recurse(tcx, ct.subtree(arg), f))
 698             }
 699             Node::Cast(_, operand, _) => recurse(tcx, ct.subtree(operand), f),
 700         }
 701     }
 702
 703     recurse(tcx, ct, &mut f)
 704 }
 705
 706 struct ConstUnifyCtxt<'tcx> {
 707     tcx: TyCtxt<'tcx>,
 708     param_env: ty::ParamEnv<'tcx>,
 709 }
 710
 711 impl<'tcx> ConstUnifyCtxt<'tcx> {
 712     // Substitutes generics repeatedly to allow AbstractConsts to unify where a
 713     // ConstKind::Unevaluated could be turned into an AbstractConst that would unify e.g.
 714     // Param(N) should unify with Param(T), substs: [Unevaluated("T2", [Unevaluated("T3", [Param(N)])])]
 715     #[inline]
 716     #[instrument(skip(self), level = "debug")]
 717     fn try_replace_substs_in_root(
 718         &self,
 719         mut abstr_const: AbstractConst<'tcx>,
 720     ) -> Option<AbstractConst<'tcx>> {
 721         while let Node::Leaf(ct) = abstr_const.root(self.tcx) {
 722             match AbstractConst::from_const(self.tcx, ct) {
 723                 Ok(Some(act)) => abstr_const = act,
 724                 Ok(None) => break,
 725                 Err(_) => return None,
 726             }
 727         }
 728
 729         Some(abstr_const)
 730     }
 731
 732     /// Tries to unify two abstract constants using structural equality.
 733     #[instrument(skip(self), level = "debug")]
 734     fn try_unify(&self, a: AbstractConst<'tcx>, b: AbstractConst<'tcx>) -> bool {
 735         let a = if let Some(a) = self.try_replace_substs_in_root(a) {
 736             a
 737         } else {
 738             return true;
 739         };
 740
 741         let b = if let Some(b) = self.try_replace_substs_in_root(b) {
 742             b
 743         } else {
 744             return true;
 745         };
 746
 747         let a_root = a.root(self.tcx);
 748         let b_root = b.root(self.tcx);
 749         debug!(?a_root, ?b_root);
 750
 751         match (a_root, b_root) {
 752             (Node::Leaf(a_ct), Node::Leaf(b_ct)) => {
 753                 let a_ct = a_ct.eval(self.tcx, self.param_env);
 754                 debug!("a_ct evaluated: {:?}", a_ct);
 755                 let b_ct = b_ct.eval(self.tcx, self.param_env);
 756                 debug!("b_ct evaluated: {:?}", b_ct);
 757
 758                 if a_ct.ty() != b_ct.ty() {
 759                     return false;
 760                 }
 761
 762                 match (a_ct.val(), b_ct.val()) {
 763                     // We can just unify errors with everything to reduce the amount of
 764                     // emitted errors here.
 765                     (ty::ConstKind::Error(_), _) | (_, ty::ConstKind::Error(_)) => true,
 766                     (ty::ConstKind::Param(a_param), ty::ConstKind::Param(b_param)) => {
 767                         a_param == b_param
 768                     }
 769                     (ty::ConstKind::Value(a_val), ty::ConstKind::Value(b_val)) => a_val == b_val,
 770                     // If we have `fn a<const N: usize>() -> [u8; N + 1]` and `fn b<const M: usize>() -> [u8; 1 + M]`
 771                     // we do not want to use `assert_eq!(a(), b())` to infer that `N` and `M` have to be `1`. This
 772                     // means that we only allow inference variables if they are equal.
 773                     (ty::ConstKind::Infer(a_val), ty::ConstKind::Infer(b_val)) => a_val == b_val,
 774                     // We expand generic anonymous constants at the start of this function, so this
 775                     // branch should only be taking when dealing with associated constants, at
 776                     // which point directly comparing them seems like the desired behavior.
 777                     //
 778                     // FIXME(generic_const_exprs): This isn't actually the case.
 779                     // We also take this branch for concrete anonymous constants and
 780                     // expand generic anonymous constants with concrete substs.
 781                     (ty::ConstKind::Unevaluated(a_uv), ty::ConstKind::Unevaluated(b_uv)) => {
 782                         a_uv == b_uv
 783                     }
 784                     // FIXME(generic_const_exprs): We may want to either actually try
 785                     // to evaluate `a_ct` and `b_ct` if they are are fully concrete or something like
 786                     // this, for now we just return false here.
 787                     _ => false,
 788                 }
 789             }
 790             (Node::Binop(a_op, al, ar), Node::Binop(b_op, bl, br)) if a_op == b_op => {
 791                 self.try_unify(a.subtree(al), b.subtree(bl))
 792                     && self.try_unify(a.subtree(ar), b.subtree(br))
 793             }
 794             (Node::UnaryOp(a_op, av), Node::UnaryOp(b_op, bv)) if a_op == b_op => {
 795                 self.try_unify(a.subtree(av), b.subtree(bv))
 796             }
 797             (Node::FunctionCall(a_f, a_args), Node::FunctionCall(b_f, b_args))
 798                 if a_args.len() == b_args.len() =>
 799             {
 800                 self.try_unify(a.subtree(a_f), b.subtree(b_f))
 801                     && iter::zip(a_args, b_args)
 802                         .all(|(&an, &bn)| self.try_unify(a.subtree(an), b.subtree(bn)))
 803             }
 804             (Node::Cast(a_kind, a_operand, a_ty), Node::Cast(b_kind, b_operand, b_ty))
 805                 if (a_ty == b_ty) && (a_kind == b_kind) =>
 806             {
 807                 self.try_unify(a.subtree(a_operand), b.subtree(b_operand))
 808             }
 809             // use this over `_ => false` to make adding variants to `Node` less error prone
 810             (Node::Cast(..), _)
 811             | (Node::FunctionCall(..), _)
 812             | (Node::UnaryOp(..), _)
 813             | (Node::Binop(..), _)
 814             | (Node::Leaf(..), _) => false,
 815         }
 816     }
 817 }
 818
 819 /* Think I need these changes
 820 =======
 821             match (a_ct, b_ct) {
 822                 (mir::ConstantKind::Ty(a_ct), mir::ConstantKind::Ty(b_ct)) => {
 823                     match (a_ct.val(), b_ct.val()) {
 824                         // We can just unify errors with everything to reduce the amount of
 825                         // emitted errors here.
 826                         (ty::ConstKind::Error(_), _) | (_, ty::ConstKind::Error(_)) => true,
 827                         (ty::ConstKind::Param(a_param), ty::ConstKind::Param(b_param)) => {
 828                             a_param == b_param
 829                         }
 830                         (ty::ConstKind::Value(a_val), ty::ConstKind::Value(b_val)) => {
 831                             a_val == b_val
 832                         }
 833
 834                         // If we have `fn a<const N: usize>() -> [u8; N + 1]` and `fn b<const M: usize>() -> [u8; 1 + M]`
 835                         // we do not want to use `assert_eq!(a(), b())` to infer that `N` and `M` have to be `1`. This
 836                         // means that we only allow inference variables if they are equal.
 837                         (ty::ConstKind::Infer(a_val), ty::ConstKind::Infer(b_val)) => {
 838                             a_val == b_val
 839                         }
 840                         // We expand generic anonymous constants at the start of this function, so this
 841                         // branch should only be taking when dealing with associated constants, at
 842                         // which point directly comparing them seems like the desired behavior.
 843                         //
 844                         // FIXME(generic_const_exprs): This isn't actually the case.
 845                         // We also take this branch for concrete anonymous constants and
 846                         // expand generic anonymous constants with concrete substs.
 847                         (ty::ConstKind::Unevaluated(a_uv), ty::ConstKind::Unevaluated(b_uv)) => {
 848                             a_uv == b_uv
 849                         }
 850                         // FIXME(generic_const_exprs): We may want to either actually try
 851                         // to evaluate `a_ct` and `b_ct` if they are are fully concrete or something like
 852                         // this, for now we just return false here.
 853                         _ => false,
 854                     }
 855                 }
 856                 (mir::ConstantKind::Val(a_val, a_ty), mir::ConstantKind::Val(b_val, b_ty)) => {
 857                     a_val == b_val && a_ty == b_ty
 858                 }
 859                 _ => {
 860                     // FIXME Can it happen that we need to compare ConstantKind::Ty(ConstKind::Value)
 861                     // with a ConstantKind::Val and vice versa?
 862                     false
 863 >>>>>>> 6064f16d846 (change thir to use mir::ConstantKind instead of ty::Const)
 864
 865  */