use crate::ast::{self, ExprKind};
use crate::codegen::backend::{CodegenError, CodegenResult};
use crate::codegen::ir::*;
use super::MirLowerer;
fn holds_array(lowerer: &MirLowerer<'_>, ty: &MirType) -> bool {
match ty {
MirType::Array(..) => true,
MirType::Struct(name) => lowerer
.struct_field_list(name)
.is_some_and(|fields| fields.iter().any(|(_, fty)| holds_array(lowerer, fty))),
MirType::Tuple(elems) => elems.iter().any(|t| holds_array(lowerer, t)),
_ => false,
}
}
fn is_aggregate(ty: &MirType) -> bool {
matches!(
ty,
MirType::Array(..) | MirType::Struct(_) | MirType::Tuple(_)
)
}
fn retype_scalar(value: MirConst, ty: &MirType) -> Option<MirConst> {
let (bits, signed) = match ty {
MirType::Int(size, signed) => (int_bits(*size)?, *signed),
MirType::Bool => return matches!(value, MirConst::Bool(_)).then_some(value),
MirType::Float(_) => {
return match value {
MirConst::Float(v, _) => Some(MirConst::Float(v, ty.clone())),
_ => None,
}
}
_ => return None,
};
let v: i128 = match value {
MirConst::Int(v, _) => v,
MirConst::Uint(v, _) => i128::try_from(v).ok()?,
_ => return None,
};
let (lo, hi) = if signed {
(-(1i128 << (bits - 1)), (1i128 << (bits - 1)) - 1)
} else {
(0, (1i128 << bits) - 1)
};
if v < lo || v > hi {
return None;
}
Some(if signed {
MirConst::Int(v, ty.clone())
} else {
MirConst::Uint(v as u128, ty.clone())
})
}
fn is_zero(c: &MirConst) -> bool {
match c {
MirConst::Int(v, _) => *v == 0,
MirConst::Uint(v, _) => *v == 0,
MirConst::Bool(b) => !*b,
MirConst::Float(v, _) => v.to_bits() == 0,
MirConst::Zeroed(_) => true,
MirConst::Array(_, vs) | MirConst::Struct(_, vs) => vs.iter().all(is_zero),
_ => false,
}
}
fn int_bits(size: IntSize) -> Option<u32> {
match size {
IntSize::I8 => Some(8),
IntSize::I16 => Some(16),
IntSize::I32 => Some(32),
IntSize::I64 | IntSize::ISize => Some(64),
IntSize::I128 => None,
}
}
impl<'ctx> MirLowerer<'ctx> {
pub(super) fn struct_field_list(
&self,
name: &str,
) -> Option<Vec<(Option<std::sync::Arc<str>>, MirType)>> {
match &self.module.find_type(name)?.kind {
TypeDefKind::Struct { fields, .. } => Some(fields.clone()),
_ => None,
}
}
pub(super) fn global_initializer(
&self,
name: &str,
expr: &ast::Expr,
ty: &MirType,
) -> CodegenResult<Option<MirConst>> {
if matches!(ty, MirType::Struct(n) if n.as_ref() == "BuildString") {
if let Some(text) = string_literal(expr) {
let len = MirConst::Uint(text.len() as u128, MirType::usize());
return Ok(Some(MirConst::Struct(
std::sync::Arc::from("BuildString"),
vec![
MirConst::ByteStr(text.as_bytes().to_vec()),
len,
MirConst::Uint(0, MirType::usize()),
],
)));
}
}
if !is_aggregate(ty) {
return self.scalar_initializer(name, expr, ty);
}
if let Some(c) = self.const_eval_typed(expr, ty) {
return Ok(Some(c));
}
if !holds_array(self, ty) {
if let Some(c) = self.try_const_eval(expr) {
return Ok(Some(c));
}
}
let span = expr.span;
Err(CodegenError::Rejected {
message: format!(
"the initializer of `{name}` is not a constant the compiler can evaluate"
),
location: (span.end.0 > span.start.0).then_some((span.start.0, span.end.0)),
help: Some(
"write it with literals: `[1, 2, 3]`, `[0; N]` and struct literals that name every field"
.to_string(),
),
})
}
fn scalar_initializer(
&self,
name: &str,
expr: &ast::Expr,
ty: &MirType,
) -> CodegenResult<Option<MirConst>> {
let value = self.try_const_eval(expr);
let refuse = |why: &str| {
let span = expr.span;
Err(CodegenError::Rejected {
message: format!("the initializer of `{name}` {why}"),
location: (span.end.0 > span.start.0).then_some((span.start.0, span.end.0)),
help: Some(
"use literals, other constants, arithmetic, comparisons and `as` casts between number types"
.to_string(),
),
})
};
match ty {
MirType::Bool => match value {
Some(MirConst::Bool(_)) => Ok(value),
_ => refuse("is not a boolean the compiler can evaluate"),
},
MirType::Float(_) => match value {
Some(MirConst::Float(v, _)) => Ok(Some(MirConst::Float(v, ty.clone()))),
Some(MirConst::Int(v, _)) => Ok(Some(MirConst::Float(v as f64, ty.clone()))),
Some(MirConst::Uint(v, _)) => Ok(Some(MirConst::Float(v as f64, ty.clone()))),
_ => refuse("is not a number the compiler can evaluate"),
},
MirType::Int(..) => match value {
Some(MirConst::Int(..)) | Some(MirConst::Uint(..)) => Ok(value),
_ => refuse("is not an integer the compiler can evaluate"),
},
_ => Ok(value),
}
}
fn const_eval_typed(&self, expr: &ast::Expr, ty: &MirType) -> Option<MirConst> {
match (&expr.kind, ty) {
(ExprKind::Paren(inner), _) => self.const_eval_typed(inner, ty),
(ExprKind::Array(elems), MirType::Array(elem, n)) => {
if elems.len() as u64 != *n {
return None;
}
let values: Option<Vec<MirConst>> = elems
.iter()
.map(|e| self.const_eval_typed(e, elem))
.collect();
Some(MirConst::Array((**elem).clone(), values?))
}
(ExprKind::ArrayRepeat { element, count }, MirType::Array(elem, n)) => {
let count = match self.try_const_eval(count)? {
MirConst::Int(v, _) => u64::try_from(v).ok()?,
MirConst::Uint(v, _) => u64::try_from(v).ok()?,
_ => return None,
};
if count != *n {
return None;
}
let value = self.const_eval_typed(element, elem)?;
if is_zero(&value) {
return Some(MirConst::Zeroed(ty.clone()));
}
Some(MirConst::Array(
(**elem).clone(),
vec![value; count as usize],
))
}
(
ExprKind::Struct {
fields, rest: None, ..
},
MirType::Struct(name),
) => self.const_struct(name, fields),
(ExprKind::Tuple(elems), MirType::Tuple(tys)) if elems.len() == tys.len() => {
let values: Option<Vec<MirConst>> = elems
.iter()
.zip(tys)
.map(|(e, t)| self.const_eval_typed(e, t))
.collect();
Some(MirConst::Struct(MirType::tuple_type_name(tys), values?))
}
(_, MirType::Array(..) | MirType::Struct(_) | MirType::Tuple(_)) => None,
_ => retype_scalar(self.try_const_eval(expr)?, ty),
}
}
fn const_struct(
&self,
name: &std::sync::Arc<str>,
fields: &[ast::FieldExpr],
) -> Option<MirConst> {
let decl = self.struct_field_list(name)?;
if decl.len() != fields.len() {
return None;
}
let mut values = Vec::with_capacity(decl.len());
for (fname, fty) in &decl {
let fname = fname.as_ref()?;
let field = fields.iter().find(|f| f.name.name == *fname)?;
let value = field.value.as_ref()?;
values.push(self.const_eval_typed(value, fty)?);
}
Some(MirConst::Struct(name.clone(), values))
}
}
pub(super) fn string_literal(expr: &ast::Expr) -> Option<&str> {
match &expr.kind {
ExprKind::Paren(inner) => string_literal(inner),
ExprKind::Literal(ast::Literal::Str { value, .. }) => Some(value.as_ref()),
_ => None,
}
}