compiler/rustc_ty_utils/src/consts.rs

   1 use rustc_errors::ErrorGuaranteed;
   2 use rustc_hir::def::DefKind;
   3 use rustc_hir::def_id::LocalDefId;
   4 use rustc_index::vec::IndexVec;
   5 use rustc_middle::mir::interpret::{LitToConstError, LitToConstInput};
   6 use rustc_middle::ty::abstract_const::{CastKind, Node, NodeId};
   7 use rustc_middle::ty::{self, TyCtxt, TypeVisitable};
   8 use rustc_middle::{mir, thir};
   9 use rustc_span::Span;
  10 use rustc_target::abi::VariantIdx;
  11
  12 use std::iter;
  13
  14 use crate::errors::{GenericConstantTooComplex, GenericConstantTooComplexSub};
  15
  16 /// Destructures array, ADT or tuple constants into the constants
  17 /// of their fields.
  18 pub(crate) fn destructure_const<'tcx>(
  19     tcx: TyCtxt<'tcx>,
  20     const_: ty::Const<'tcx>,
  21 ) -> ty::DestructuredConst<'tcx> {
  22     let ty::ConstKind::Value(valtree) = const_.kind() else {
  23         bug!("cannot destructure constant {:?}", const_)
  24     };
  25
  26     let branches = match valtree {
  27         ty::ValTree::Branch(b) => b,
  28         _ => bug!("cannot destructure constant {:?}", const_),
  29     };
  30
  31     let (fields, variant) = match const_.ty().kind() {
  32         ty::Array(inner_ty, _) | ty::Slice(inner_ty) => {
  33             // construct the consts for the elements of the array/slice
  34             let field_consts = branches
  35                 .iter()
  36                 .map(|b| tcx.mk_const(ty::ConstS { kind: ty::ConstKind::Value(*b), ty: *inner_ty }))
  37                 .collect::<Vec<_>>();
  38             debug!(?field_consts);
  39
  40             (field_consts, None)
  41         }
  42         ty::Adt(def, _) if def.variants().is_empty() => bug!("unreachable"),
  43         ty::Adt(def, substs) => {
  44             let (variant_idx, branches) = if def.is_enum() {
  45                 let (head, rest) = branches.split_first().unwrap();
  46                 (VariantIdx::from_u32(head.unwrap_leaf().try_to_u32().unwrap()), rest)
  47             } else {
  48                 (VariantIdx::from_u32(0), branches)
  49             };
  50             let fields = &def.variant(variant_idx).fields;
  51             let mut field_consts = Vec::with_capacity(fields.len());
  52
  53             for (field, field_valtree) in iter::zip(fields, branches) {
  54                 let field_ty = field.ty(tcx, substs);
  55                 let field_const = tcx.mk_const(ty::ConstS {
  56                     kind: ty::ConstKind::Value(*field_valtree),
  57                     ty: field_ty,
  58                 });
  59                 field_consts.push(field_const);
  60             }
  61             debug!(?field_consts);
  62
  63             (field_consts, Some(variant_idx))
  64         }
  65         ty::Tuple(elem_tys) => {
  66             let fields = iter::zip(*elem_tys, branches)
  67                 .map(|(elem_ty, elem_valtree)| {
  68                     tcx.mk_const(ty::ConstS {
  69                         kind: ty::ConstKind::Value(*elem_valtree),
  70                         ty: elem_ty,
  71                     })
  72                 })
  73                 .collect::<Vec<_>>();
  74
  75             (fields, None)
  76         }
  77         _ => bug!("cannot destructure constant {:?}", const_),
  78     };
  79
  80     let fields = tcx.arena.alloc_from_iter(fields.into_iter());
  81
  82     ty::DestructuredConst { variant, fields }
  83 }
  84
  85 pub struct AbstractConstBuilder<'a, 'tcx> {
  86     tcx: TyCtxt<'tcx>,
  87     body_id: thir::ExprId,
  88     body: &'a thir::Thir<'tcx>,
  89     /// The current WIP node tree.
  90     nodes: IndexVec<NodeId, Node<'tcx>>,
  91 }
  92
  93 impl<'a, 'tcx> AbstractConstBuilder<'a, 'tcx> {
  94     fn root_span(&self) -> Span {
  95         self.body.exprs[self.body_id].span
  96     }
  97
  98     fn error(&mut self, sub: GenericConstantTooComplexSub) -> Result<!, ErrorGuaranteed> {
  99         let reported = self.tcx.sess.emit_err(GenericConstantTooComplex {
 100             span: self.root_span(),
 101             maybe_supported: None,
 102             sub,
 103         });
 104
 105         Err(reported)
 106     }
 107
 108     fn maybe_supported_error(
 109         &mut self,
 110         sub: GenericConstantTooComplexSub,
 111     ) -> Result<!, ErrorGuaranteed> {
 112         let reported = self.tcx.sess.emit_err(GenericConstantTooComplex {
 113             span: self.root_span(),
 114             maybe_supported: Some(()),
 115             sub,
 116         });
 117
 118         Err(reported)
 119     }
 120
 121     #[instrument(skip(tcx, body, body_id), level = "debug")]
 122     pub fn new(
 123         tcx: TyCtxt<'tcx>,
 124         (body, body_id): (&'a thir::Thir<'tcx>, thir::ExprId),
 125     ) -> Result<Option<AbstractConstBuilder<'a, 'tcx>>, ErrorGuaranteed> {
 126         let builder = AbstractConstBuilder { tcx, body_id, body, nodes: IndexVec::new() };
 127
 128         struct IsThirPolymorphic<'a, 'tcx> {
 129             is_poly: bool,
 130             thir: &'a thir::Thir<'tcx>,
 131         }
 132
 133         use crate::rustc_middle::thir::visit::Visitor;
 134         use thir::visit;
 135
 136         impl<'a, 'tcx> IsThirPolymorphic<'a, 'tcx> {
 137             fn expr_is_poly(&mut self, expr: &thir::Expr<'tcx>) -> bool {
 138                 if expr.ty.has_param_types_or_consts() {
 139                     return true;
 140                 }
 141
 142                 match expr.kind {
 143                     thir::ExprKind::NamedConst { substs, .. } => substs.has_param_types_or_consts(),
 144                     thir::ExprKind::ConstParam { .. } => true,
 145                     thir::ExprKind::Repeat { value, count } => {
 146                         self.visit_expr(&self.thir()[value]);
 147                         count.has_param_types_or_consts()
 148                     }
 149                     _ => false,
 150                 }
 151             }
 152
 153             fn pat_is_poly(&mut self, pat: &thir::Pat<'tcx>) -> bool {
 154                 if pat.ty.has_param_types_or_consts() {
 155                     return true;
 156                 }
 157
 158                 match pat.kind {
 159                     thir::PatKind::Constant { value } => value.has_param_types_or_consts(),
 160                     thir::PatKind::Range(box thir::PatRange { lo, hi, .. }) => {
 161                         lo.has_param_types_or_consts() || hi.has_param_types_or_consts()
 162                     }
 163                     _ => false,
 164                 }
 165             }
 166         }
 167
 168         impl<'a, 'tcx> visit::Visitor<'a, 'tcx> for IsThirPolymorphic<'a, 'tcx> {
 169             fn thir(&self) -> &'a thir::Thir<'tcx> {
 170                 &self.thir
 171             }
 172
 173             #[instrument(skip(self), level = "debug")]
 174             fn visit_expr(&mut self, expr: &thir::Expr<'tcx>) {
 175                 self.is_poly |= self.expr_is_poly(expr);
 176                 if !self.is_poly {
 177                     visit::walk_expr(self, expr)
 178                 }
 179             }
 180
 181             #[instrument(skip(self), level = "debug")]
 182             fn visit_pat(&mut self, pat: &thir::Pat<'tcx>) {
 183                 self.is_poly |= self.pat_is_poly(pat);
 184                 if !self.is_poly {
 185                     visit::walk_pat(self, pat);
 186                 }
 187             }
 188         }
 189
 190         let mut is_poly_vis = IsThirPolymorphic { is_poly: false, thir: body };
 191         visit::walk_expr(&mut is_poly_vis, &body[body_id]);
 192         debug!("AbstractConstBuilder: is_poly={}", is_poly_vis.is_poly);
 193         if !is_poly_vis.is_poly {
 194             return Ok(None);
 195         }
 196
 197         Ok(Some(builder))
 198     }
 199
 200     /// We do not allow all binary operations in abstract consts, so filter disallowed ones.
 201     fn check_binop(op: mir::BinOp) -> bool {
 202         use mir::BinOp::*;
 203         match op {
 204             Add | Sub | Mul | Div | Rem | BitXor | BitAnd | BitOr | Shl | Shr | Eq | Lt | Le
 205             | Ne | Ge | Gt => true,
 206             Offset => false,
 207         }
 208     }
 209
 210     /// While we currently allow all unary operations, we still want to explicitly guard against
 211     /// future changes here.
 212     fn check_unop(op: mir::UnOp) -> bool {
 213         use mir::UnOp::*;
 214         match op {
 215             Not | Neg => true,
 216         }
 217     }
 218
 219     /// Builds the abstract const by walking the thir and bailing out when
 220     /// encountering an unsupported operation.
 221     pub fn build(mut self) -> Result<&'tcx [Node<'tcx>], ErrorGuaranteed> {
 222         debug!("AbstractConstBuilder::build: body={:?}", &*self.body);
 223         self.recurse_build(self.body_id)?;
 224
 225         Ok(self.tcx.arena.alloc_from_iter(self.nodes.into_iter()))
 226     }
 227
 228     fn recurse_build(&mut self, node: thir::ExprId) -> Result<NodeId, ErrorGuaranteed> {
 229         use thir::ExprKind;
 230         let node = &self.body.exprs[node];
 231         Ok(match &node.kind {
 232             // I dont know if handling of these 3 is correct
 233             &ExprKind::Scope { value, .. } => self.recurse_build(value)?,
 234             &ExprKind::PlaceTypeAscription { source, .. }
 235             | &ExprKind::ValueTypeAscription { source, .. } => self.recurse_build(source)?,
 236             &ExprKind::Literal { lit, neg } => {
 237                 let sp = node.span;
 238                 let constant = match self.tcx.at(sp).lit_to_const(LitToConstInput {
 239                     lit: &lit.node,
 240                     ty: node.ty,
 241                     neg,
 242                 }) {
 243                     Ok(c) => c,
 244                     Err(LitToConstError::Reported) => self.tcx.const_error(node.ty),
 245                     Err(LitToConstError::TypeError) => {
 246                         bug!("encountered type error in lit_to_const")
 247                     }
 248                 };
 249
 250                 self.nodes.push(Node::Leaf(constant))
 251             }
 252             &ExprKind::NonHirLiteral { lit, user_ty: _ } => {
 253                 let val = ty::ValTree::from_scalar_int(lit);
 254                 self.nodes.push(Node::Leaf(ty::Const::from_value(self.tcx, val, node.ty)))
 255             }
 256             &ExprKind::ZstLiteral { user_ty: _ } => {
 257                 let val = ty::ValTree::zst();
 258                 self.nodes.push(Node::Leaf(ty::Const::from_value(self.tcx, val, node.ty)))
 259             }
 260             &ExprKind::NamedConst { def_id, substs, user_ty: _ } => {
 261                 let uneval = ty::Unevaluated::new(ty::WithOptConstParam::unknown(def_id), substs);
 262
 263                 let constant = self
 264                     .tcx
 265                     .mk_const(ty::ConstS { kind: ty::ConstKind::Unevaluated(uneval), ty: node.ty });
 266
 267                 self.nodes.push(Node::Leaf(constant))
 268             }
 269
 270             ExprKind::ConstParam { param, .. } => {
 271                 let const_param = self
 272                     .tcx
 273                     .mk_const(ty::ConstS { kind: ty::ConstKind::Param(*param), ty: node.ty });
 274                 self.nodes.push(Node::Leaf(const_param))
 275             }
 276
 277             ExprKind::Call { fun, args, .. } => {
 278                 let fun = self.recurse_build(*fun)?;
 279
 280                 let mut new_args = Vec::<NodeId>::with_capacity(args.len());
 281                 for &id in args.iter() {
 282                     new_args.push(self.recurse_build(id)?);
 283                 }
 284                 let new_args = self.tcx.arena.alloc_slice(&new_args);
 285                 self.nodes.push(Node::FunctionCall(fun, new_args))
 286             }
 287             &ExprKind::Binary { op, lhs, rhs } if Self::check_binop(op) => {
 288                 let lhs = self.recurse_build(lhs)?;
 289                 let rhs = self.recurse_build(rhs)?;
 290                 self.nodes.push(Node::Binop(op, lhs, rhs))
 291             }
 292             &ExprKind::Unary { op, arg } if Self::check_unop(op) => {
 293                 let arg = self.recurse_build(arg)?;
 294                 self.nodes.push(Node::UnaryOp(op, arg))
 295             }
 296             // This is necessary so that the following compiles:
 297             //
 298             // ```
 299             // fn foo<const N: usize>(a: [(); N + 1]) {
 300             //     bar::<{ N + 1 }>();
 301             // }
 302             // ```
 303             ExprKind::Block { block } => {
 304                 if let thir::Block { stmts: box [], expr: Some(e), .. } = &self.body.blocks[*block]
 305                 {
 306                     self.recurse_build(*e)?
 307                 } else {
 308                     self.maybe_supported_error(GenericConstantTooComplexSub::BlockNotSupported(
 309                         node.span,
 310                     ))?
 311                 }
 312             }
 313             // `ExprKind::Use` happens when a `hir::ExprKind::Cast` is a
 314             // "coercion cast" i.e. using a coercion or is a no-op.
 315             // This is important so that `N as usize as usize` doesnt unify with `N as usize`. (untested)
 316             &ExprKind::Use { source } => {
 317                 let arg = self.recurse_build(source)?;
 318                 self.nodes.push(Node::Cast(CastKind::Use, arg, node.ty))
 319             }
 320             &ExprKind::Cast { source } => {
 321                 let arg = self.recurse_build(source)?;
 322                 self.nodes.push(Node::Cast(CastKind::As, arg, node.ty))
 323             }
 324             ExprKind::Borrow { arg, .. } => {
 325                 let arg_node = &self.body.exprs[*arg];
 326
 327                 // Skip reborrows for now until we allow Deref/Borrow/AddressOf
 328                 // expressions.
 329                 // FIXME(generic_const_exprs): Verify/explain why this is sound
 330                 if let ExprKind::Deref { arg } = arg_node.kind {
 331                     self.recurse_build(arg)?
 332                 } else {
 333                     self.maybe_supported_error(GenericConstantTooComplexSub::BorrowNotSupported(
 334                         node.span,
 335                     ))?
 336                 }
 337             }
 338             // FIXME(generic_const_exprs): We may want to support these.
 339             ExprKind::AddressOf { .. } | ExprKind::Deref { .. } => self.maybe_supported_error(
 340                 GenericConstantTooComplexSub::AddressAndDerefNotSupported(node.span),
 341             )?,
 342             ExprKind::Repeat { .. } | ExprKind::Array { .. } => self.maybe_supported_error(
 343                 GenericConstantTooComplexSub::ArrayNotSupported(node.span),
 344             )?,
 345             ExprKind::NeverToAny { .. } => self.maybe_supported_error(
 346                 GenericConstantTooComplexSub::NeverToAnyNotSupported(node.span),
 347             )?,
 348             ExprKind::Tuple { .. } => self.maybe_supported_error(
 349                 GenericConstantTooComplexSub::TupleNotSupported(node.span),
 350             )?,
 351             ExprKind::Index { .. } => self.maybe_supported_error(
 352                 GenericConstantTooComplexSub::IndexNotSupported(node.span),
 353             )?,
 354             ExprKind::Field { .. } => self.maybe_supported_error(
 355                 GenericConstantTooComplexSub::FieldNotSupported(node.span),
 356             )?,
 357             ExprKind::ConstBlock { .. } => self.maybe_supported_error(
 358                 GenericConstantTooComplexSub::ConstBlockNotSupported(node.span),
 359             )?,
 360             ExprKind::Adt(_) => self
 361                 .maybe_supported_error(GenericConstantTooComplexSub::AdtNotSupported(node.span))?,
 362             // dont know if this is correct
 363             ExprKind::Pointer { .. } => {
 364                 self.error(GenericConstantTooComplexSub::PointerNotSupported(node.span))?
 365             }
 366             ExprKind::Yield { .. } => {
 367                 self.error(GenericConstantTooComplexSub::YieldNotSupported(node.span))?
 368             }
 369             ExprKind::Continue { .. } | ExprKind::Break { .. } | ExprKind::Loop { .. } => {
 370                 self.error(GenericConstantTooComplexSub::LoopNotSupported(node.span))?
 371             }
 372             ExprKind::Box { .. } => {
 373                 self.error(GenericConstantTooComplexSub::BoxNotSupported(node.span))?
 374             }
 375
 376             ExprKind::Unary { .. } => unreachable!(),
 377             // we handle valid unary/binary ops above
 378             ExprKind::Binary { .. } => {
 379                 self.error(GenericConstantTooComplexSub::BinaryNotSupported(node.span))?
 380             }
 381             ExprKind::LogicalOp { .. } => {
 382                 self.error(GenericConstantTooComplexSub::LogicalOpNotSupported(node.span))?
 383             }
 384             ExprKind::Assign { .. } | ExprKind::AssignOp { .. } => {
 385                 self.error(GenericConstantTooComplexSub::AssignNotSupported(node.span))?
 386             }
 387             ExprKind::Closure { .. } | ExprKind::Return { .. } => {
 388                 self.error(GenericConstantTooComplexSub::ClosureAndReturnNotSupported(node.span))?
 389             }
 390             // let expressions imply control flow
 391             ExprKind::Match { .. } | ExprKind::If { .. } | ExprKind::Let { .. } => {
 392                 self.error(GenericConstantTooComplexSub::ControlFlowNotSupported(node.span))?
 393             }
 394             ExprKind::InlineAsm { .. } => {
 395                 self.error(GenericConstantTooComplexSub::InlineAsmNotSupported(node.span))?
 396             }
 397
 398             // we dont permit let stmts so `VarRef` and `UpvarRef` cant happen
 399             ExprKind::VarRef { .. }
 400             | ExprKind::UpvarRef { .. }
 401             | ExprKind::StaticRef { .. }
 402             | ExprKind::ThreadLocalRef(_) => {
 403                 self.error(GenericConstantTooComplexSub::OperationNotSupported(node.span))?
 404             }
 405         })
 406     }
 407 }
 408
 409 /// Builds an abstract const, do not use this directly, but use `AbstractConst::new` instead.
 410 pub fn thir_abstract_const<'tcx>(
 411     tcx: TyCtxt<'tcx>,
 412     def: ty::WithOptConstParam<LocalDefId>,
 413 ) -> Result<Option<&'tcx [Node<'tcx>]>, ErrorGuaranteed> {
 414     if tcx.features().generic_const_exprs {
 415         match tcx.def_kind(def.did) {
 416             // FIXME(generic_const_exprs): We currently only do this for anonymous constants,
 417             // meaning that we do not look into associated constants. I(@lcnr) am not yet sure whether
 418             // we want to look into them or treat them as opaque projections.
 419             //
 420             // Right now we do neither of that and simply always fail to unify them.
 421             DefKind::AnonConst | DefKind::InlineConst => (),
 422             _ => return Ok(None),
 423         }
 424
 425         let body = tcx.thir_body(def)?;
 426
 427         AbstractConstBuilder::new(tcx, (&*body.0.borrow(), body.1))?
 428             .map(AbstractConstBuilder::build)
 429             .transpose()
 430     } else {
 431         Ok(None)
 432     }
 433 }
 434
 435 pub fn provide(providers: &mut ty::query::Providers) {
 436     *providers = ty::query::Providers {
 437         destructure_const,
 438         thir_abstract_const: |tcx, def_id| {
 439             let def_id = def_id.expect_local();
 440             if let Some(def) = ty::WithOptConstParam::try_lookup(def_id, tcx) {
 441                 tcx.thir_abstract_const_of_const_arg(def)
 442             } else {
 443                 thir_abstract_const(tcx, ty::WithOptConstParam::unknown(def_id))
 444             }
 445         },
 446         thir_abstract_const_of_const_arg: |tcx, (did, param_did)| {
 447             thir_abstract_const(
 448                 tcx,
 449                 ty::WithOptConstParam { did, const_param_did: Some(param_did) },
 450             )
 451         },
 452         ..*providers
 453     };
 454 }