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};
10 use rustc_target::abi::VariantIdx;
14 use crate::errors::{GenericConstantTooComplex, GenericConstantTooComplexSub};
16 /// Destructures array, ADT or tuple constants into the constants
18 pub(crate) fn destructure_const<'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_)
26 let branches = match valtree {
27 ty::ValTree::Branch(b) => b,
28 _ => bug!("cannot destructure constant {:?}", const_),
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
36 .map(|b| tcx.mk_const(ty::ConstS { kind: ty::ConstKind::Value(*b), ty: *inner_ty }))
38 debug!(?field_consts);
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)
48 (VariantIdx::from_u32(0), branches)
50 let fields = &def.variant(variant_idx).fields;
51 let mut field_consts = Vec::with_capacity(fields.len());
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),
59 field_consts.push(field_const);
61 debug!(?field_consts);
63 (field_consts, Some(variant_idx))
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),
77 _ => bug!("cannot destructure constant {:?}", const_),
80 let fields = tcx.arena.alloc_from_iter(fields.into_iter());
82 ty::DestructuredConst { variant, fields }
85 pub struct AbstractConstBuilder<'a, 'tcx> {
87 body_id: thir::ExprId,
88 body: &'a thir::Thir<'tcx>,
89 /// The current WIP node tree.
90 nodes: IndexVec<NodeId, Node<'tcx>>,
93 impl<'a, 'tcx> AbstractConstBuilder<'a, 'tcx> {
94 fn root_span(&self) -> Span {
95 self.body.exprs[self.body_id].span
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,
108 fn maybe_supported_error(
110 sub: GenericConstantTooComplexSub,
111 ) -> Result<!, ErrorGuaranteed> {
112 let reported = self.tcx.sess.emit_err(GenericConstantTooComplex {
113 span: self.root_span(),
114 maybe_supported: Some(()),
121 #[instrument(skip(tcx, body, body_id), level = "debug")]
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() };
128 struct IsThirPolymorphic<'a, 'tcx> {
130 thir: &'a thir::Thir<'tcx>,
133 use crate::rustc_middle::thir::visit::Visitor;
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() {
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()
153 fn pat_is_poly(&mut self, pat: &thir::Pat<'tcx>) -> bool {
154 if pat.ty.has_param_types_or_consts() {
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()
168 impl<'a, 'tcx> visit::Visitor<'a, 'tcx> for IsThirPolymorphic<'a, 'tcx> {
169 fn thir(&self) -> &'a thir::Thir<'tcx> {
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);
177 visit::walk_expr(self, expr)
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);
185 visit::walk_pat(self, pat);
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 {
200 /// We do not allow all binary operations in abstract consts, so filter disallowed ones.
201 fn check_binop(op: mir::BinOp) -> bool {
204 Add | Sub | Mul | Div | Rem | BitXor | BitAnd | BitOr | Shl | Shr | Eq | Lt | Le
205 | Ne | Ge | Gt => true,
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 {
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)?;
225 Ok(self.tcx.arena.alloc_from_iter(self.nodes.into_iter()))
228 fn recurse_build(&mut self, node: thir::ExprId) -> Result<NodeId, ErrorGuaranteed> {
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 } => {
238 let constant = match self.tcx.at(sp).lit_to_const(LitToConstInput {
244 Err(LitToConstError::Reported) => self.tcx.const_error(node.ty),
245 Err(LitToConstError::TypeError) => {
246 bug!("encountered type error in lit_to_const")
250 self.nodes.push(Node::Leaf(constant))
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)))
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)))
260 &ExprKind::NamedConst { def_id, substs, user_ty: _ } => {
261 let uneval = ty::Unevaluated::new(ty::WithOptConstParam::unknown(def_id), substs);
265 .mk_const(ty::ConstS { kind: ty::ConstKind::Unevaluated(uneval), ty: node.ty });
267 self.nodes.push(Node::Leaf(constant))
270 ExprKind::ConstParam { param, .. } => {
271 let const_param = self
273 .mk_const(ty::ConstS { kind: ty::ConstKind::Param(*param), ty: node.ty });
274 self.nodes.push(Node::Leaf(const_param))
277 ExprKind::Call { fun, args, .. } => {
278 let fun = self.recurse_build(*fun)?;
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)?);
284 let new_args = self.tcx.arena.alloc_slice(&new_args);
285 self.nodes.push(Node::FunctionCall(fun, new_args))
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))
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))
296 // This is necessary so that the following compiles:
299 // fn foo<const N: usize>(a: [(); N + 1]) {
300 // bar::<{ N + 1 }>();
303 ExprKind::Block { block } => {
304 if let thir::Block { stmts: box [], expr: Some(e), .. } = &self.body.blocks[*block]
306 self.recurse_build(*e)?
308 self.maybe_supported_error(GenericConstantTooComplexSub::BlockNotSupported(
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))
320 &ExprKind::Cast { source } => {
321 let arg = self.recurse_build(source)?;
322 self.nodes.push(Node::Cast(CastKind::As, arg, node.ty))
324 ExprKind::Borrow { arg, .. } => {
325 let arg_node = &self.body.exprs[*arg];
327 // Skip reborrows for now until we allow Deref/Borrow/AddressOf
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)?
333 self.maybe_supported_error(GenericConstantTooComplexSub::BorrowNotSupported(
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),
342 ExprKind::Repeat { .. } | ExprKind::Array { .. } => self.maybe_supported_error(
343 GenericConstantTooComplexSub::ArrayNotSupported(node.span),
345 ExprKind::NeverToAny { .. } => self.maybe_supported_error(
346 GenericConstantTooComplexSub::NeverToAnyNotSupported(node.span),
348 ExprKind::Tuple { .. } => self.maybe_supported_error(
349 GenericConstantTooComplexSub::TupleNotSupported(node.span),
351 ExprKind::Index { .. } => self.maybe_supported_error(
352 GenericConstantTooComplexSub::IndexNotSupported(node.span),
354 ExprKind::Field { .. } => self.maybe_supported_error(
355 GenericConstantTooComplexSub::FieldNotSupported(node.span),
357 ExprKind::ConstBlock { .. } => self.maybe_supported_error(
358 GenericConstantTooComplexSub::ConstBlockNotSupported(node.span),
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))?
366 ExprKind::Yield { .. } => {
367 self.error(GenericConstantTooComplexSub::YieldNotSupported(node.span))?
369 ExprKind::Continue { .. } | ExprKind::Break { .. } | ExprKind::Loop { .. } => {
370 self.error(GenericConstantTooComplexSub::LoopNotSupported(node.span))?
372 ExprKind::Box { .. } => {
373 self.error(GenericConstantTooComplexSub::BoxNotSupported(node.span))?
376 ExprKind::Unary { .. } => unreachable!(),
377 // we handle valid unary/binary ops above
378 ExprKind::Binary { .. } => {
379 self.error(GenericConstantTooComplexSub::BinaryNotSupported(node.span))?
381 ExprKind::LogicalOp { .. } => {
382 self.error(GenericConstantTooComplexSub::LogicalOpNotSupported(node.span))?
384 ExprKind::Assign { .. } | ExprKind::AssignOp { .. } => {
385 self.error(GenericConstantTooComplexSub::AssignNotSupported(node.span))?
387 ExprKind::Closure { .. } | ExprKind::Return { .. } => {
388 self.error(GenericConstantTooComplexSub::ClosureAndReturnNotSupported(node.span))?
390 // let expressions imply control flow
391 ExprKind::Match { .. } | ExprKind::If { .. } | ExprKind::Let { .. } => {
392 self.error(GenericConstantTooComplexSub::ControlFlowNotSupported(node.span))?
394 ExprKind::InlineAsm { .. } => {
395 self.error(GenericConstantTooComplexSub::InlineAsmNotSupported(node.span))?
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))?
409 /// Builds an abstract const, do not use this directly, but use `AbstractConst::new` instead.
410 pub fn thir_abstract_const<'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.
420 // Right now we do neither of that and simply always fail to unify them.
421 DefKind::AnonConst | DefKind::InlineConst => (),
422 _ => return Ok(None),
425 let body = tcx.thir_body(def)?;
427 AbstractConstBuilder::new(tcx, (&*body.0.borrow(), body.1))?
428 .map(AbstractConstBuilder::build)
435 pub fn provide(providers: &mut ty::query::Providers) {
436 *providers = ty::query::Providers {
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)
443 thir_abstract_const(tcx, ty::WithOptConstParam::unknown(def_id))
446 thir_abstract_const_of_const_arg: |tcx, (did, param_did)| {
449 ty::WithOptConstParam { did, const_param_did: Some(param_did) },