src/librustc_middle/ty/consts.rs

   1 use crate::mir::interpret::ConstValue;
   2 use crate::mir::interpret::{LitToConstInput, Scalar};
   3 use crate::ty::subst::InternalSubsts;
   4 use crate::ty::{self, Ty, TyCtxt};
   5 use crate::ty::{ParamEnv, ParamEnvAnd};
   6 use rustc_errors::ErrorReported;
   7 use rustc_hir as hir;
   8 use rustc_hir::def_id::LocalDefId;
   9 use rustc_macros::HashStable;
  10
  11 mod int;
  12 mod kind;
  13
  14 pub use int::*;
  15 pub use kind::*;
  16
  17 /// Typed constant value.
  18 #[derive(Copy, Clone, Debug, Hash, TyEncodable, TyDecodable, Eq, PartialEq, Ord, PartialOrd)]
  19 #[derive(HashStable)]
  20 pub struct Const<'tcx> {
  21     pub ty: Ty<'tcx>,
  22
  23     pub val: ConstKind<'tcx>,
  24 }
  25
  26 #[cfg(target_arch = "x86_64")]
  27 static_assert_size!(Const<'_>, 48);
  28
  29 impl<'tcx> Const<'tcx> {
  30     /// Literals and const generic parameters are eagerly converted to a constant, everything else
  31     /// becomes `Unevaluated`.
  32     pub fn from_anon_const(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &'tcx Self {
  33         Self::from_opt_const_arg_anon_const(tcx, ty::WithOptConstParam::unknown(def_id))
  34     }
  35
  36     pub fn from_opt_const_arg_anon_const(
  37         tcx: TyCtxt<'tcx>,
  38         def: ty::WithOptConstParam<LocalDefId>,
  39     ) -> &'tcx Self {
  40         debug!("Const::from_anon_const(def={:?})", def);
  41
  42         let hir_id = tcx.hir().local_def_id_to_hir_id(def.did);
  43
  44         let body_id = match tcx.hir().get(hir_id) {
  45             hir::Node::AnonConst(ac) => ac.body,
  46             _ => span_bug!(
  47                 tcx.def_span(def.did.to_def_id()),
  48                 "from_anon_const can only process anonymous constants"
  49             ),
  50         };
  51
  52         let expr = &tcx.hir().body(body_id).value;
  53
  54         let ty = tcx.type_of(def.def_id_for_type_of());
  55
  56         let lit_input = match expr.kind {
  57             hir::ExprKind::Lit(ref lit) => Some(LitToConstInput { lit: &lit.node, ty, neg: false }),
  58             hir::ExprKind::Unary(hir::UnOp::UnNeg, ref expr) => match expr.kind {
  59                 hir::ExprKind::Lit(ref lit) => {
  60                     Some(LitToConstInput { lit: &lit.node, ty, neg: true })
  61                 }
  62                 _ => None,
  63             },
  64             _ => None,
  65         };
  66
  67         if let Some(lit_input) = lit_input {
  68             // If an error occurred, ignore that it's a literal and leave reporting the error up to
  69             // mir.
  70             if let Ok(c) = tcx.at(expr.span).lit_to_const(lit_input) {
  71                 return c;
  72             } else {
  73                 tcx.sess.delay_span_bug(expr.span, "Const::from_anon_const: couldn't lit_to_const");
  74             }
  75         }
  76
  77         // Unwrap a block, so that e.g. `{ P }` is recognised as a parameter. Const arguments
  78         // currently have to be wrapped in curly brackets, so it's necessary to special-case.
  79         let expr = match &expr.kind {
  80             hir::ExprKind::Block(block, _) if block.stmts.is_empty() && block.expr.is_some() => {
  81                 block.expr.as_ref().unwrap()
  82             }
  83             _ => expr,
  84         };
  85
  86         use hir::{def::DefKind::ConstParam, def::Res, ExprKind, Path, QPath};
  87         let val = match expr.kind {
  88             ExprKind::Path(QPath::Resolved(_, &Path { res: Res::Def(ConstParam, def_id), .. })) => {
  89                 // Find the name and index of the const parameter by indexing the generics of
  90                 // the parent item and construct a `ParamConst`.
  91                 let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
  92                 let item_id = tcx.hir().get_parent_node(hir_id);
  93                 let item_def_id = tcx.hir().local_def_id(item_id);
  94                 let generics = tcx.generics_of(item_def_id.to_def_id());
  95                 let index =
  96                     generics.param_def_id_to_index[&tcx.hir().local_def_id(hir_id).to_def_id()];
  97                 let name = tcx.hir().name(hir_id);
  98                 ty::ConstKind::Param(ty::ParamConst::new(index, name))
  99             }
 100             _ => ty::ConstKind::Unevaluated(
 101                 def.to_global(),
 102                 InternalSubsts::identity_for_item(tcx, def.did.to_def_id()),
 103                 None,
 104             ),
 105         };
 106
 107         tcx.mk_const(ty::Const { val, ty })
 108     }
 109
 110     #[inline]
 111     /// Interns the given value as a constant.
 112     pub fn from_value(tcx: TyCtxt<'tcx>, val: ConstValue<'tcx>, ty: Ty<'tcx>) -> &'tcx Self {
 113         tcx.mk_const(Self { val: ConstKind::Value(val), ty })
 114     }
 115
 116     #[inline]
 117     /// Interns the given scalar as a constant.
 118     pub fn from_scalar(tcx: TyCtxt<'tcx>, val: Scalar, ty: Ty<'tcx>) -> &'tcx Self {
 119         Self::from_value(tcx, ConstValue::Scalar(val), ty)
 120     }
 121
 122     #[inline]
 123     /// Creates a constant with the given integer value and interns it.
 124     pub fn from_bits(tcx: TyCtxt<'tcx>, bits: u128, ty: ParamEnvAnd<'tcx, Ty<'tcx>>) -> &'tcx Self {
 125         let size = tcx
 126             .layout_of(ty)
 127             .unwrap_or_else(|e| panic!("could not compute layout for {:?}: {:?}", ty, e))
 128             .size;
 129         Self::from_scalar(tcx, Scalar::from_uint(bits, size), ty.value)
 130     }
 131
 132     #[inline]
 133     /// Creates an interned zst constant.
 134     pub fn zero_sized(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> &'tcx Self {
 135         Self::from_scalar(tcx, Scalar::zst(), ty)
 136     }
 137
 138     #[inline]
 139     /// Creates an interned bool constant.
 140     pub fn from_bool(tcx: TyCtxt<'tcx>, v: bool) -> &'tcx Self {
 141         Self::from_bits(tcx, v as u128, ParamEnv::empty().and(tcx.types.bool))
 142     }
 143
 144     #[inline]
 145     /// Creates an interned usize constant.
 146     pub fn from_usize(tcx: TyCtxt<'tcx>, n: u64) -> &'tcx Self {
 147         Self::from_bits(tcx, n as u128, ParamEnv::empty().and(tcx.types.usize))
 148     }
 149
 150     #[inline]
 151     /// Attempts to evaluate the given constant to bits. Can fail to evaluate in the presence of
 152     /// generics (or erroneous code) or if the value can't be represented as bits (e.g. because it
 153     /// contains const generic parameters or pointers).
 154     pub fn try_eval_bits(
 155         &self,
 156         tcx: TyCtxt<'tcx>,
 157         param_env: ParamEnv<'tcx>,
 158         ty: Ty<'tcx>,
 159     ) -> Option<u128> {
 160         assert_eq!(self.ty, ty);
 161         let size = tcx.layout_of(param_env.with_reveal_all_normalized(tcx).and(ty)).ok()?.size;
 162         // if `ty` does not depend on generic parameters, use an empty param_env
 163         self.val.eval(tcx, param_env).try_to_bits(size)
 164     }
 165
 166     #[inline]
 167     pub fn try_eval_bool(&self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> Option<bool> {
 168         self.val.eval(tcx, param_env).try_to_bool()
 169     }
 170
 171     #[inline]
 172     pub fn try_eval_usize(&self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> Option<u64> {
 173         self.val.eval(tcx, param_env).try_to_machine_usize(tcx)
 174     }
 175
 176     #[inline]
 177     /// Tries to evaluate the constant if it is `Unevaluated`. If that doesn't succeed, return the
 178     /// unevaluated constant.
 179     pub fn eval(&self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> &Const<'tcx> {
 180         if let Some(val) = self.val.try_eval(tcx, param_env) {
 181             match val {
 182                 Ok(val) => Const::from_value(tcx, val, self.ty),
 183                 Err(ErrorReported) => tcx.const_error(self.ty),
 184             }
 185         } else {
 186             self
 187         }
 188     }
 189
 190     #[inline]
 191     /// Panics if the value cannot be evaluated or doesn't contain a valid integer of the given type.
 192     pub fn eval_bits(&self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: Ty<'tcx>) -> u128 {
 193         self.try_eval_bits(tcx, param_env, ty)
 194             .unwrap_or_else(|| bug!("expected bits of {:#?}, got {:#?}", ty, self))
 195     }
 196
 197     #[inline]
 198     /// Panics if the value cannot be evaluated or doesn't contain a valid `usize`.
 199     pub fn eval_usize(&self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> u64 {
 200         self.try_eval_usize(tcx, param_env)
 201             .unwrap_or_else(|| bug!("expected usize, got {:#?}", self))
 202     }
 203 }