rust/compiler/rustc_ty_utils/src/consts.rs

use rustc_errors::ErrorGuaranteed;
use rustc_hir::def::DefKind;
use rustc_hir::def_id::LocalDefId;
use rustc_middle::mir::interpret::{LitToConstError, LitToConstInput};
use rustc_middle::thir::visit;
use rustc_middle::thir::visit::Visitor;
use rustc_middle::ty::abstract_const::CastKind;
use rustc_middle::ty::{self, ConstKind, Expr, TyCtxt, TypeVisitable};
use rustc_middle::{mir, thir};
use rustc_span::Span;
use rustc_target::abi::VariantIdx;

use std::iter;

use crate::errors::{GenericConstantTooComplex, GenericConstantTooComplexSub};

/// Destructures array, ADT or tuple constants into the constants
/// of their fields.
pub(crate) fn destructure_const<'tcx>(
    tcx: TyCtxt<'tcx>,
    const_: ty::Const<'tcx>,
) -> ty::DestructuredConst<'tcx> {
    let ty::ConstKind::Value(valtree) = const_.kind() else {
        bug!("cannot destructure constant {:?}", const_)
    };

    let branches = match valtree {
        ty::ValTree::Branch(b) => b,
        _ => bug!("cannot destructure constant {:?}", const_),
    };

    let (fields, variant) = match const_.ty().kind() {
        ty::Array(inner_ty, _) | ty::Slice(inner_ty) => {
            // construct the consts for the elements of the array/slice
            let field_consts = branches
                .iter()
                .map(|b| tcx.mk_const(ty::ConstKind::Value(*b), *inner_ty))
                .collect::<Vec<_>>();
            debug!(?field_consts);

            (field_consts, None)
        }
        ty::Adt(def, _) if def.variants().is_empty() => bug!("unreachable"),
        ty::Adt(def, substs) => {
            let (variant_idx, branches) = if def.is_enum() {
                let (head, rest) = branches.split_first().unwrap();
                (VariantIdx::from_u32(head.unwrap_leaf().try_to_u32().unwrap()), rest)
            } else {
                (VariantIdx::from_u32(0), branches)
            };
            let fields = &def.variant(variant_idx).fields;
            let mut field_consts = Vec::with_capacity(fields.len());

            for (field, field_valtree) in iter::zip(fields, branches) {
                let field_ty = field.ty(tcx, substs);
                let field_const = tcx.mk_const(ty::ConstKind::Value(*field_valtree), field_ty);
                field_consts.push(field_const);
            }
            debug!(?field_consts);

            (field_consts, Some(variant_idx))
        }
        ty::Tuple(elem_tys) => {
            let fields = iter::zip(*elem_tys, branches)
                .map(|(elem_ty, elem_valtree)| {
                    tcx.mk_const(ty::ConstKind::Value(*elem_valtree), elem_ty)
                })
                .collect::<Vec<_>>();

            (fields, None)
        }
        _ => bug!("cannot destructure constant {:?}", const_),
    };

    let fields = tcx.arena.alloc_from_iter(fields.into_iter());

    ty::DestructuredConst { variant, fields }
}

/// We do not allow all binary operations in abstract consts, so filter disallowed ones.
fn check_binop(op: mir::BinOp) -> bool {
    use mir::BinOp::*;
    match op {
        Add | Sub | Mul | Div | Rem | BitXor | BitAnd | BitOr | Shl | Shr | Eq | Lt | Le | Ne
        | Ge | Gt => true,
        Offset => false,
    }
}

/// While we currently allow all unary operations, we still want to explicitly guard against
/// future changes here.
fn check_unop(op: mir::UnOp) -> bool {
    use mir::UnOp::*;
    match op {
        Not | Neg => true,
    }
}

fn recurse_build<'tcx>(
    tcx: TyCtxt<'tcx>,
    body: &thir::Thir<'tcx>,
    node: thir::ExprId,
    root_span: Span,
) -> Result<ty::Const<'tcx>, ErrorGuaranteed> {
    use thir::ExprKind;
    let node = &body.exprs[node];
    Ok(match &node.kind {
        // I dont know if handling of these 3 is correct
        &ExprKind::Scope { value, .. } => recurse_build(tcx, body, value, root_span)?,
        &ExprKind::PlaceTypeAscription { source, .. }
        | &ExprKind::ValueTypeAscription { source, .. } => {
            recurse_build(tcx, body, source, root_span)?
        }
        &ExprKind::Literal { lit, neg } => {
            let sp = node.span;
            match tcx.at(sp).lit_to_const(LitToConstInput { lit: &lit.node, ty: node.ty, neg }) {
                Ok(c) => c,
                Err(LitToConstError::Reported(guar)) => {
                    tcx.const_error_with_guaranteed(node.ty, guar)
                }
                Err(LitToConstError::TypeError) => {
                    bug!("encountered type error in lit_to_const")
                }
            }
        }
        &ExprKind::NonHirLiteral { lit, user_ty: _ } => {
            let val = ty::ValTree::from_scalar_int(lit);
            ty::Const::from_value(tcx, val, node.ty)
        }
        &ExprKind::ZstLiteral { user_ty: _ } => {
            let val = ty::ValTree::zst();
            ty::Const::from_value(tcx, val, node.ty)
        }
        &ExprKind::NamedConst { def_id, substs, user_ty: _ } => {
            let uneval = ty::UnevaluatedConst::new(ty::WithOptConstParam::unknown(def_id), substs);
            tcx.mk_const(ty::ConstKind::Unevaluated(uneval), node.ty)
        }
        ExprKind::ConstParam { param, .. } => tcx.mk_const(ty::ConstKind::Param(*param), node.ty),

        ExprKind::Call { fun, args, .. } => {
            let fun = recurse_build(tcx, body, *fun, root_span)?;

            let mut new_args = Vec::<ty::Const<'tcx>>::with_capacity(args.len());
            for &id in args.iter() {
                new_args.push(recurse_build(tcx, body, id, root_span)?);
            }
            let new_args = tcx.mk_const_list(new_args.iter());
            tcx.mk_const(ConstKind::Expr(Expr::FunctionCall(fun, new_args)), node.ty)
        }
        &ExprKind::Binary { op, lhs, rhs } if check_binop(op) => {
            let lhs = recurse_build(tcx, body, lhs, root_span)?;
            let rhs = recurse_build(tcx, body, rhs, root_span)?;
            tcx.mk_const(ConstKind::Expr(Expr::Binop(op, lhs, rhs)), node.ty)
        }
        &ExprKind::Unary { op, arg } if check_unop(op) => {
            let arg = recurse_build(tcx, body, arg, root_span)?;
            tcx.mk_const(ConstKind::Expr(Expr::UnOp(op, arg)), node.ty)
        }
        // This is necessary so that the following compiles:
        //
        // ```
        // fn foo<const N: usize>(a: [(); N + 1]) {
        //     bar::<{ N + 1 }>();
        // }
        // ```
        ExprKind::Block { block } => {
            if let thir::Block { stmts: box [], expr: Some(e), .. } = &body.blocks[*block] {
                recurse_build(tcx, body, *e, root_span)?
            } else {
                maybe_supported_error(
                    tcx,
                    GenericConstantTooComplexSub::BlockNotSupported(node.span),
                    root_span,
                )?
            }
        }
        // `ExprKind::Use` happens when a `hir::ExprKind::Cast` is a
        // "coercion cast" i.e. using a coercion or is a no-op.
        // This is important so that `N as usize as usize` doesnt unify with `N as usize`. (untested)
        &ExprKind::Use { source } => {
            let arg = recurse_build(tcx, body, source, root_span)?;
            tcx.mk_const(ConstKind::Expr(Expr::Cast(CastKind::Use, arg, node.ty)), node.ty)
        }
        &ExprKind::Cast { source } => {
            let arg = recurse_build(tcx, body, source, root_span)?;
            tcx.mk_const(ConstKind::Expr(Expr::Cast(CastKind::As, arg, node.ty)), node.ty)
        }
        ExprKind::Borrow { arg, .. } => {
            let arg_node = &body.exprs[*arg];

            // Skip reborrows for now until we allow Deref/Borrow/AddressOf
            // expressions.
            // FIXME(generic_const_exprs): Verify/explain why this is sound
            if let ExprKind::Deref { arg } = arg_node.kind {
                recurse_build(tcx, body, arg, root_span)?
            } else {
                maybe_supported_error(
                    tcx,
                    GenericConstantTooComplexSub::BorrowNotSupported(node.span),
                    root_span,
                )?
            }
        }
        // FIXME(generic_const_exprs): We may want to support these.
        ExprKind::AddressOf { .. } | ExprKind::Deref { .. } => maybe_supported_error(
            tcx,
            GenericConstantTooComplexSub::AddressAndDerefNotSupported(node.span),
            root_span,
        )?,
        ExprKind::Repeat { .. } | ExprKind::Array { .. } => maybe_supported_error(
            tcx,
            GenericConstantTooComplexSub::ArrayNotSupported(node.span),
            root_span,
        )?,
        ExprKind::NeverToAny { .. } => maybe_supported_error(
            tcx,
            GenericConstantTooComplexSub::NeverToAnyNotSupported(node.span),
            root_span,
        )?,
        ExprKind::Tuple { .. } => maybe_supported_error(
            tcx,
            GenericConstantTooComplexSub::TupleNotSupported(node.span),
            root_span,
        )?,
        ExprKind::Index { .. } => maybe_supported_error(
            tcx,
            GenericConstantTooComplexSub::IndexNotSupported(node.span),
            root_span,
        )?,
        ExprKind::Field { .. } => maybe_supported_error(
            tcx,
            GenericConstantTooComplexSub::FieldNotSupported(node.span),
            root_span,
        )?,
        ExprKind::ConstBlock { .. } => maybe_supported_error(
            tcx,
            GenericConstantTooComplexSub::ConstBlockNotSupported(node.span),
            root_span,
        )?,
        ExprKind::Adt(_) => maybe_supported_error(
            tcx,
            GenericConstantTooComplexSub::AdtNotSupported(node.span),
            root_span,
        )?,
        // dont know if this is correct
        ExprKind::Pointer { .. } => {
            error(tcx, GenericConstantTooComplexSub::PointerNotSupported(node.span), root_span)?
        }
        ExprKind::Yield { .. } => {
            error(tcx, GenericConstantTooComplexSub::YieldNotSupported(node.span), root_span)?
        }
        ExprKind::Continue { .. } | ExprKind::Break { .. } | ExprKind::Loop { .. } => {
            error(tcx, GenericConstantTooComplexSub::LoopNotSupported(node.span), root_span)?
        }
        ExprKind::Box { .. } => {
            error(tcx, GenericConstantTooComplexSub::BoxNotSupported(node.span), root_span)?
        }

        ExprKind::Unary { .. } => unreachable!(),
        // we handle valid unary/binary ops above
        ExprKind::Binary { .. } => {
            error(tcx, GenericConstantTooComplexSub::BinaryNotSupported(node.span), root_span)?
        }
        ExprKind::LogicalOp { .. } => {
            error(tcx, GenericConstantTooComplexSub::LogicalOpNotSupported(node.span), root_span)?
        }
        ExprKind::Assign { .. } | ExprKind::AssignOp { .. } => {
            error(tcx, GenericConstantTooComplexSub::AssignNotSupported(node.span), root_span)?
        }
        ExprKind::Closure { .. } | ExprKind::Return { .. } => error(
            tcx,
            GenericConstantTooComplexSub::ClosureAndReturnNotSupported(node.span),
            root_span,
        )?,
        // let expressions imply control flow
        ExprKind::Match { .. } | ExprKind::If { .. } | ExprKind::Let { .. } => {
            error(tcx, GenericConstantTooComplexSub::ControlFlowNotSupported(node.span), root_span)?
        }
        ExprKind::InlineAsm { .. } => {
            error(tcx, GenericConstantTooComplexSub::InlineAsmNotSupported(node.span), root_span)?
        }

        // we dont permit let stmts so `VarRef` and `UpvarRef` cant happen
        ExprKind::VarRef { .. }
        | ExprKind::UpvarRef { .. }
        | ExprKind::StaticRef { .. }
        | ExprKind::ThreadLocalRef(_) => {
            error(tcx, GenericConstantTooComplexSub::OperationNotSupported(node.span), root_span)?
        }
    })
}

struct IsThirPolymorphic<'a, 'tcx> {
    is_poly: bool,
    thir: &'a thir::Thir<'tcx>,
}

fn error<'tcx>(
    tcx: TyCtxt<'tcx>,
    sub: GenericConstantTooComplexSub,
    root_span: Span,
) -> Result<!, ErrorGuaranteed> {
    let reported = tcx.sess.emit_err(GenericConstantTooComplex {
        span: root_span,
        maybe_supported: None,
        sub,
    });

    Err(reported)
}

fn maybe_supported_error<'tcx>(
    tcx: TyCtxt<'tcx>,
    sub: GenericConstantTooComplexSub,
    root_span: Span,
) -> Result<!, ErrorGuaranteed> {
    let reported = tcx.sess.emit_err(GenericConstantTooComplex {
        span: root_span,
        maybe_supported: Some(()),
        sub,
    });

    Err(reported)
}

impl<'a, 'tcx> IsThirPolymorphic<'a, 'tcx> {
    fn expr_is_poly(&mut self, expr: &thir::Expr<'tcx>) -> bool {
        if expr.ty.has_non_region_param() {
            return true;
        }

        match expr.kind {
            thir::ExprKind::NamedConst { substs, .. } => substs.has_non_region_param(),
            thir::ExprKind::ConstParam { .. } => true,
            thir::ExprKind::Repeat { value, count } => {
                self.visit_expr(&self.thir()[value]);
                count.has_non_region_param()
            }
            _ => false,
        }
    }
    fn pat_is_poly(&mut self, pat: &thir::Pat<'tcx>) -> bool {
        if pat.ty.has_non_region_param() {
            return true;
        }

        match pat.kind {
            thir::PatKind::Constant { value } => value.has_non_region_param(),
            thir::PatKind::Range(box thir::PatRange { lo, hi, .. }) => {
                lo.has_non_region_param() || hi.has_non_region_param()
            }
            _ => false,
        }
    }
}

impl<'a, 'tcx> visit::Visitor<'a, 'tcx> for IsThirPolymorphic<'a, 'tcx> {
    fn thir(&self) -> &'a thir::Thir<'tcx> {
        &self.thir
    }

    #[instrument(skip(self), level = "debug")]
    fn visit_expr(&mut self, expr: &thir::Expr<'tcx>) {
        self.is_poly |= self.expr_is_poly(expr);
        if !self.is_poly {
            visit::walk_expr(self, expr)
        }
    }

    #[instrument(skip(self), level = "debug")]
    fn visit_pat(&mut self, pat: &thir::Pat<'tcx>) {
        self.is_poly |= self.pat_is_poly(pat);
        if !self.is_poly {
            visit::walk_pat(self, pat);
        }
    }
}

/// Builds an abstract const, do not use this directly, but use `AbstractConst::new` instead.
pub fn thir_abstract_const<'tcx>(
    tcx: TyCtxt<'tcx>,
    def: ty::WithOptConstParam<LocalDefId>,
) -> Result<Option<ty::Const<'tcx>>, ErrorGuaranteed> {
    if tcx.features().generic_const_exprs {
        match tcx.def_kind(def.did) {
            // FIXME(generic_const_exprs): We currently only do this for anonymous constants,
            // meaning that we do not look into associated constants. I(@lcnr) am not yet sure whether
            // we want to look into them or treat them as opaque projections.
            //
            // Right now we do neither of that and simply always fail to unify them.
            DefKind::AnonConst | DefKind::InlineConst => (),
            _ => return Ok(None),
        }

        let body = tcx.thir_body(def)?;
        let (body, body_id) = (&*body.0.borrow(), body.1);

        let mut is_poly_vis = IsThirPolymorphic { is_poly: false, thir: body };
        visit::walk_expr(&mut is_poly_vis, &body[body_id]);
        if !is_poly_vis.is_poly {
            return Ok(None);
        }

        let root_span = body.exprs[body_id].span;

        Some(recurse_build(tcx, body, body_id, root_span)).transpose()
    } else {
        Ok(None)
    }
}

pub fn provide(providers: &mut ty::query::Providers) {
    *providers = ty::query::Providers {
        destructure_const,
        thir_abstract_const: |tcx, def_id| {
            let def_id = def_id.expect_local();
            if let Some(def) = ty::WithOptConstParam::try_lookup(def_id, tcx) {
                tcx.thir_abstract_const_of_const_arg(def)
            } else {
                thir_abstract_const(tcx, ty::WithOptConstParam::unknown(def_id))
            }
        },
        thir_abstract_const_of_const_arg: |tcx, (did, param_did)| {
            thir_abstract_const(
                tcx,
                ty::WithOptConstParam { did, const_param_did: Some(param_did) },
            )
        },
        ..*providers
    };
}