use std::{
collections::{BTreeMap, BTreeSet},
error::Error,
fmt,
};
use crate::{
parsing::{
ParsedFile,
ast::{
ContractDeclarationKind, ContractDefinitionContent, ContractSource,
EnumVariantDeclaration, GenericDeclarationList, LayoutContractDeclaration,
StructureFieldDeclaration,
},
},
runtime::{NativePassMode, NativeRegisterClass},
rust_lib::NativeTypeRegistration,
semantic::{
CanonicalSymbolPath, GenericParameterId, ModuleGraph, SemanticGenericArgument,
SemanticNamedType, SemanticType, TypeLowerer, TypeLoweringError, normalize_type,
},
};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TypeOrigin {
Rust,
Lehit,
CompilerPrimitive,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TypeMetadata {
pub path: CanonicalSymbolPath,
pub origin: TypeOrigin,
pub size: usize,
pub align: usize,
pub native_pass_mode: Option<NativePassMode>,
pub kind: TypeMetadataKind,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TypeMetadataKind {
Scalar {
bits: u16,
signed: bool,
},
Structure {
fields: Vec<FieldMetadata>,
},
Enum {
tag_offset: usize,
tag_bits: u16,
variants: Vec<EnumVariantMetadata>,
},
Native,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EnumVariantMetadata {
pub index: u32,
pub name: String,
pub tag: u128,
pub matching_tags: Vec<u128>,
pub fallback: bool,
pub writes_tag: bool,
pub payload_offset: Option<usize>,
pub payload_type: Option<SemanticType>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FieldMetadata {
pub index: u32,
pub name: String,
pub public: bool,
pub offset: usize,
pub type_: SemanticType,
}
#[derive(Debug, Clone, Default)]
pub struct TypeMetadataRegistry {
types: BTreeMap<CanonicalSymbolPath, TypeMetadata>,
specializations: Vec<(SemanticNamedType, TypeMetadata)>,
}
impl TypeMetadataRegistry {
pub fn build(
graph: &ModuleGraph,
files: &BTreeMap<String, ParsedFile>,
native_types: &BTreeMap<CanonicalSymbolPath, NativeTypeRegistration>,
) -> Result<Self, Vec<TypeMetadataError>> {
Self::build_with_specializations(graph, files, native_types, &[])
}
pub fn build_with_specializations(
graph: &ModuleGraph,
files: &BTreeMap<String, ParsedFile>,
native_types: &BTreeMap<CanonicalSymbolPath, NativeTypeRegistration>,
specializations: &[(SemanticNamedType, String)],
) -> Result<Self, Vec<TypeMetadataError>> {
let mut builder = RegistryBuilder {
graph,
files,
native_types,
drafts: BTreeMap::new(),
metadata: BTreeMap::new(),
specializations: Vec::new(),
active: BTreeSet::new(),
errors: Vec::new(),
};
builder.collect_drafts();
let paths = builder
.drafts
.iter()
.filter_map(|(path, draft)| (!draft.is_generic()).then_some(path.clone()))
.collect::<Vec<_>>();
for path in paths {
builder.layout_named(&path);
}
for path in native_types.keys() {
builder.layout_named(path);
}
for (type_, requesting_module) in specializations {
builder.layout_specialized(type_, requesting_module);
}
if builder.errors.is_empty() {
Ok(Self {
types: builder.metadata,
specializations: builder.specializations,
})
} else {
Err(builder.errors)
}
}
pub fn get(&self, path: &CanonicalSymbolPath) -> Option<&TypeMetadata> {
self.types.get(path)
}
pub fn get_named(&self, named: &SemanticNamedType) -> Option<&TypeMetadata> {
if named.generic_arguments.is_empty() {
return self.get(&named.path);
}
self.specializations
.iter()
.find_map(|(key, metadata)| (key == named).then_some(metadata))
}
pub fn metadata_of(&self, type_: &SemanticType) -> Option<&TypeMetadata> {
let SemanticType::Named(named) = type_ else {
return None;
};
self.get_named(named)
}
#[cfg(test)]
pub(crate) fn insert_specialization(
&mut self,
type_: SemanticNamedType,
metadata: TypeMetadata,
) -> Option<TypeMetadata> {
if let Some((_, current)) = self
.specializations
.iter_mut()
.find(|(key, _)| key == &type_)
{
return Some(std::mem::replace(current, metadata));
}
self.specializations.push((type_, metadata));
None
}
pub fn layout_of(&self, type_: &SemanticType) -> Option<(usize, usize)> {
match type_ {
SemanticType::Void => Some((0, 1)),
SemanticType::Named(named) => {
if named.path.module == crate::core_lib::BOX_MODULE_FILE_PATH
&& named.path.local == "Box"
&& named.generic_arguments.len() == 1
{
return Some((std::mem::size_of::<usize>(), std::mem::align_of::<usize>()));
}
self.get_named(named)
.cloned()
.or_else(|| {
named
.generic_arguments
.is_empty()
.then(|| primitive_metadata(&named.path))
.flatten()
})
.map(|metadata| (metadata.size, metadata.align))
}
SemanticType::Reference { .. } | SemanticType::Pointer { .. } => {
Some((std::mem::size_of::<usize>(), std::mem::align_of::<usize>()))
}
SemanticType::Array {
item,
size: Some(size),
} => {
let (item_size, item_align) = self.layout_of(item)?;
Some((
align_up(item_size, item_align).checked_mul(*size)?,
item_align,
))
}
SemanticType::Tuple(items) => layout_sequence(self, items),
_ => None,
}
}
pub fn iter(&self) -> impl Iterator<Item = &TypeMetadata> {
self.types
.values()
.chain(self.specializations.iter().map(|(_, metadata)| metadata))
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TypeMetadataError {
MissingParsedModule(String),
InvalidStringId {
module: String,
id: u32,
},
TypeLowering {
field: String,
error: TypeLoweringError,
},
UnknownLayout(CanonicalSymbolPath),
RecursiveByValue(CanonicalSymbolPath),
InvalidNativeLayout {
path: CanonicalSymbolPath,
span: Option<crate::parsing::Span>,
variant_span: Option<crate::parsing::Span>,
reason: NativeLayoutErrorKind,
},
InvalidNativePassMode(CanonicalSymbolPath),
InvalidGenericSpecialization {
type_: SemanticNamedType,
reason: String,
},
}
impl fmt::Display for TypeMetadataError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::MissingParsedModule(module) => write!(f, "missing parsed module `{module}`"),
Self::InvalidStringId { module, id } => {
write!(f, "module `{module}` contains invalid StringId({id})")
}
Self::TypeLowering { field, error } => {
write!(f, "cannot lower field `{field}`: {error}")
}
Self::UnknownLayout(path) => write!(
f,
"type `{}::{}` has no layout metadata",
path.module, path.local
),
Self::RecursiveByValue(path) => write!(
f,
"type `{}::{}` recursively contains itself by value",
path.module, path.local
),
Self::InvalidNativeLayout { path, reason, .. } => write!(
f,
"native layout for `{}::{}` is invalid: {reason}",
path.module, path.local
),
Self::InvalidNativePassMode(path) => write!(
f,
"native pass mode for `{}::{}` is invalid",
path.module, path.local
),
Self::InvalidGenericSpecialization { type_, reason } => write!(
f,
"generic specialization `{}::{}` is invalid: {reason}",
type_.path.module, type_.path.local
),
}
}
}
impl Error for TypeMetadataError {}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NativeLayoutErrorKind {
InvalidAlignment,
InvalidScalar,
InvalidStructure,
EmptyEnum,
DuplicateVariantIndex {
index: u32,
},
InvalidPayload {
variant: Option<u32>,
offset: Option<usize>,
layout_size: usize,
},
InvalidTagStorage {
offset: usize,
bits: u16,
layout_size: usize,
},
TagCountMismatch,
DuplicateTag {
tag: u128,
},
TagOutOfRange {
tag: u128,
bits: u16,
},
InvalidNicheRange,
InvalidNicheDataVariant,
InvalidSingleVariant,
}
impl fmt::Display for NativeLayoutErrorKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Self::InvalidAlignment => "invalid size or alignment",
Self::InvalidScalar => "scalar size does not match its bit width",
Self::InvalidStructure => "structure field metadata is invalid",
Self::EmptyEnum => "enum has no variants",
Self::DuplicateVariantIndex { index } => {
return write!(f, "enum contains duplicate semantic variant index {index}");
}
Self::InvalidPayload {
variant,
offset,
layout_size,
} => {
return write!(
f,
"enum payload metadata is invalid for variant {variant:?}: offset {offset:?}, enum size {layout_size}"
);
}
Self::InvalidTagStorage {
offset,
bits,
layout_size,
} => {
return write!(
f,
"enum tag at offset {offset} with width {bits} bits exceeds enum size {layout_size}"
);
}
Self::TagCountMismatch => "direct tag count differs from the variant count",
Self::DuplicateTag { tag } => {
return write!(f, "direct enum contains duplicate physical tag {tag}");
}
Self::TagOutOfRange { tag, bits } => {
return write!(f, "physical tag {tag} does not fit in {bits} bits");
}
Self::InvalidNicheRange => "niche variant range is invalid or incomplete",
Self::InvalidNicheDataVariant => {
"niche data variant is missing or overlaps the niche range"
}
Self::InvalidSingleVariant => "single-variant encoding requires exactly one variant",
})
}
}
#[derive(Clone)]
struct StructureDraft {
span: crate::parsing::Span,
module: String,
file_path: String,
generic_parameters: Option<GenericDeclarationList>,
fields: Vec<StructureFieldDeclaration>,
}
#[derive(Clone)]
struct EnumDraft {
span: crate::parsing::Span,
module: String,
file_path: String,
generic_parameters: Option<GenericDeclarationList>,
variants: Vec<EnumVariantDeclaration>,
}
#[derive(Clone)]
enum LayoutDraft {
Structure(StructureDraft),
Enum(EnumDraft),
}
impl LayoutDraft {
fn span(&self) -> crate::parsing::Span {
match self {
Self::Structure(draft) => draft.span,
Self::Enum(draft) => draft.span,
}
}
fn is_generic(&self) -> bool {
match self {
Self::Structure(draft) => draft.generic_parameters.is_some(),
Self::Enum(draft) => draft.generic_parameters.is_some(),
}
}
}
struct RegistryBuilder<'a> {
graph: &'a ModuleGraph,
files: &'a BTreeMap<String, ParsedFile>,
native_types: &'a BTreeMap<CanonicalSymbolPath, NativeTypeRegistration>,
drafts: BTreeMap<CanonicalSymbolPath, LayoutDraft>,
metadata: BTreeMap<CanonicalSymbolPath, TypeMetadata>,
specializations: Vec<(SemanticNamedType, TypeMetadata)>,
active: BTreeSet<CanonicalSymbolPath>,
errors: Vec<TypeMetadataError>,
}
impl RegistryBuilder<'_> {
fn collect_drafts(&mut self) {
for module in self.graph.modules() {
let Some(file) = self.files.get(&module.path) else {
self.errors
.push(TypeMetadataError::MissingParsedModule(module.path.clone()));
continue;
};
self.collect_content(
&module.path,
file,
"",
&file.ast.contract_definition_content,
);
}
}
fn collect_content(
&mut self,
module: &str,
file: &ParsedFile,
prefix: &str,
content: &ContractDefinitionContent,
) {
for access in &content.contract_accesses {
let Some(name) = file.data.strings.get(access.ident.string.0 as usize) else {
self.errors.push(TypeMetadataError::InvalidStringId {
module: module.to_owned(),
id: access.ident.string.0,
});
continue;
};
let local = if prefix.is_empty() {
name.clone()
} else {
format!("{prefix}.{name}")
};
match &access.source {
ContractSource::Definition(definition) => {
self.collect_content(module, file, &local, &definition.content);
}
ContractSource::Declaration(declaration) => {
let layout = match &declaration.kind {
ContractDeclarationKind::LayoutOnly(layout) => Some(layout),
ContractDeclarationKind::FunctionAndLayout(declaration) => {
Some(&declaration.layout)
}
_ => None,
};
if matches!(layout, Some(LayoutContractDeclaration::Structure(_))) {
if let Some(definition) = &declaration.definition {
self.drafts.insert(
CanonicalSymbolPath {
module: module.to_owned(),
local: local.clone(),
},
LayoutDraft::Structure(StructureDraft {
span: declaration.span,
module: module.to_owned(),
file_path: module.to_owned(),
generic_parameters: access.generic_declaration_list.clone(),
fields: definition.content.field_declarations.clone(),
}),
);
}
}
if matches!(layout, Some(LayoutContractDeclaration::Enum(_))) {
if let Some(definition) = &declaration.definition {
self.drafts.insert(
CanonicalSymbolPath {
module: module.to_owned(),
local: local.clone(),
},
LayoutDraft::Enum(EnumDraft {
span: declaration.span,
module: module.to_owned(),
file_path: module.to_owned(),
generic_parameters: access.generic_declaration_list.clone(),
variants: definition.content.variant_declarations.clone(),
}),
);
}
}
if let Some(definition) = &declaration.definition {
self.collect_content(module, file, &local, &definition.content);
}
}
ContractSource::Access(_) | ContractSource::File(_) => {}
}
}
}
fn layout_specialized(
&mut self,
type_: &SemanticNamedType,
requesting_module: &str,
) -> Option<TypeMetadata> {
if let Some((_, metadata)) = self
.specializations
.iter()
.find(|(existing, _)| existing == type_)
{
return Some(metadata.clone());
}
if let Some(LayoutDraft::Enum(draft)) = self.drafts.get(&type_.path).cloned() {
return self.layout_specialized_enum(type_, requesting_module, &draft);
}
let Some(LayoutDraft::Structure(draft)) = self.drafts.get(&type_.path).cloned() else {
self.errors
.push(TypeMetadataError::InvalidGenericSpecialization {
type_: type_.clone(),
reason: "no generic layout template exists for this type".into(),
});
return None;
};
let Some(parameters) = draft.generic_parameters.as_ref() else {
self.errors
.push(TypeMetadataError::InvalidGenericSpecialization {
type_: type_.clone(),
reason: "the nominal type is not generic".into(),
});
return None;
};
let file = self.files.get(&draft.file_path)?;
let lowerer = match TypeLowerer::new(self.graph, file, &draft.module)
.with_generic_parameters(Some(parameters))
{
Ok(lowerer) => lowerer,
Err(error) => {
self.errors.push(TypeMetadataError::TypeLowering {
field: type_.path.local.clone(),
error,
});
return None;
}
};
let semantic_parameters = lowerer.generic_parameters();
if semantic_parameters.len() != type_.generic_arguments.len() {
self.errors
.push(TypeMetadataError::InvalidGenericSpecialization {
type_: type_.clone(),
reason: format!(
"expected {} generic arguments, got {}",
semantic_parameters.len(),
type_.generic_arguments.len()
),
});
return None;
}
let mut substitutions = BTreeMap::<GenericParameterId, SemanticType>::new();
for (parameter, argument) in semantic_parameters.iter().zip(&type_.generic_arguments) {
let SemanticGenericArgument::Type(argument) = argument else {
self.errors
.push(TypeMetadataError::InvalidGenericSpecialization {
type_: type_.clone(),
reason: format!("`{}` requires a type argument", parameter.name),
});
return None;
};
substitutions.insert(parameter.id, argument.clone());
}
let mut offset = 0usize;
let mut structure_align = 1usize;
let mut fields = Vec::new();
for (index, field) in draft.fields.iter().enumerate() {
let name = file
.data
.strings
.get(field.ident.string.0 as usize)?
.clone();
let lowered = match lowerer.lower(&field.value_type) {
Ok(type_) => type_,
Err(error) => {
self.errors.push(TypeMetadataError::TypeLowering {
field: format!("{}.{name}", type_.path.local),
error,
});
return None;
}
};
let concrete =
match normalize_type(&lowered, &substitutions, self.graph, requesting_module) {
Ok(type_) => type_,
Err(error) => {
self.errors
.push(TypeMetadataError::InvalidGenericSpecialization {
type_: type_.clone(),
reason: error.to_string(),
});
return None;
}
};
let (size, align) = self.layout_type(&concrete)?;
offset = align_up(offset, align);
fields.push(FieldMetadata {
index: index as u32,
name,
public: field.pub_visible.is_some(),
offset,
type_: concrete,
});
offset = offset.checked_add(size)?;
structure_align = structure_align.max(align);
}
let metadata = TypeMetadata {
path: type_.path.clone(),
origin: TypeOrigin::Lehit,
size: align_up(offset, structure_align),
align: structure_align,
native_pass_mode: None,
kind: TypeMetadataKind::Structure { fields },
};
self.specializations.push((type_.clone(), metadata.clone()));
Some(metadata)
}
fn layout_specialized_enum(
&mut self,
type_: &SemanticNamedType,
requesting_module: &str,
draft: &EnumDraft,
) -> Option<TypeMetadata> {
let parameters = draft.generic_parameters.as_ref()?;
let file = self.files.get(&draft.file_path)?;
let lowerer = match TypeLowerer::new(self.graph, file, &draft.module)
.with_generic_parameters(Some(parameters))
{
Ok(lowerer) => lowerer,
Err(error) => {
self.errors.push(TypeMetadataError::TypeLowering {
field: type_.path.local.clone(),
error,
});
return None;
}
};
let semantic_parameters = lowerer.generic_parameters();
if semantic_parameters.len() != type_.generic_arguments.len() {
self.errors
.push(TypeMetadataError::InvalidGenericSpecialization {
type_: type_.clone(),
reason: format!(
"expected {} generic arguments, got {}",
semantic_parameters.len(),
type_.generic_arguments.len()
),
});
return None;
}
let mut substitutions = BTreeMap::new();
for (parameter, argument) in semantic_parameters.iter().zip(&type_.generic_arguments) {
let SemanticGenericArgument::Type(argument) = argument else {
self.errors
.push(TypeMetadataError::InvalidGenericSpecialization {
type_: type_.clone(),
reason: format!("`{}` requires a type argument", parameter.name),
});
return None;
};
substitutions.insert(parameter.id, argument.clone());
}
let mut lowered = Vec::with_capacity(draft.variants.len());
let mut payload_size = 0usize;
let mut payload_align = 1usize;
for (index, variant) in draft.variants.iter().enumerate() {
let name = file
.data
.strings
.get(variant.ident.string.0 as usize)?
.clone();
let payload_type = if let Some(value_type) = &variant.value_type {
let unresolved = match lowerer.lower(value_type) {
Ok(type_) => type_,
Err(error) => {
self.errors.push(TypeMetadataError::TypeLowering {
field: format!("{}::{name}", type_.path.local),
error,
});
return None;
}
};
let concrete = match normalize_type(
&unresolved,
&substitutions,
self.graph,
requesting_module,
) {
Ok(type_) => type_,
Err(error) => {
self.errors
.push(TypeMetadataError::InvalidGenericSpecialization {
type_: type_.clone(),
reason: error.to_string(),
});
return None;
}
};
let (size, align) = self.layout_type(&concrete)?;
payload_size = payload_size.max(size);
payload_align = payload_align.max(align);
Some(concrete)
} else {
None
};
lowered.push((index as u32, name, payload_type));
}
let nullable_niche = (type_.path.module == crate::core_lib::OPTION_MODULE_FILE_PATH
&& type_.path.local == "Option"
&& lowered.len() == 2)
.then(|| {
let none = lowered
.iter()
.position(|(_, name, payload)| name == "None" && payload.is_none())?;
let some = lowered.iter().position(|(_, name, payload)| {
name == "Some" && payload.as_ref().is_some_and(type_has_zero_niche)
})?;
let bits = match payload_size {
1 => 8,
2 => 16,
4 => 32,
8 => 64,
_ => return None,
};
Some((none, some, bits))
})
.flatten();
let metadata = if let Some((none, some, tag_bits)) = nullable_niche {
let variants = lowered
.iter()
.enumerate()
.map(
|(position, (index, name, payload_type))| EnumVariantMetadata {
index: *index,
name: name.clone(),
tag: 0,
matching_tags: (position == none).then_some(vec![0]).unwrap_or_default(),
fallback: position == some,
writes_tag: position == none,
payload_offset: (position == some).then_some(0),
payload_type: payload_type.clone(),
},
)
.collect();
TypeMetadata {
path: type_.path.clone(),
origin: TypeOrigin::Lehit,
size: payload_size,
align: payload_align,
native_pass_mode: None,
kind: TypeMetadataKind::Enum {
tag_offset: 0,
tag_bits,
variants,
},
}
} else if let [(index, name, payload_type)] = lowered.as_slice() {
let (size, align, payload_offset) = if payload_type.is_some() {
(payload_size, payload_align, Some(0))
} else {
(0, 1, None)
};
TypeMetadata {
path: type_.path.clone(),
origin: TypeOrigin::Lehit,
size,
align,
native_pass_mode: None,
kind: TypeMetadataKind::Enum {
tag_offset: 0,
tag_bits: 8,
variants: vec![EnumVariantMetadata {
index: *index,
name: name.clone(),
tag: 0,
matching_tags: Vec::new(),
fallback: true,
writes_tag: false,
payload_offset,
payload_type: payload_type.clone(),
}],
},
}
} else {
let (tag_bits, tag_size, tag_align) = match lowered.len() {
0..=256 => (8, 1, 1),
257..=65_536 => (16, 2, 2),
65_537..=4_294_967_296 => (32, 4, 4),
_ => (64, 8, 8),
};
let align = tag_align.max(payload_align);
let payload_offset = align_up(tag_size, payload_align);
let size = align_up(payload_offset.checked_add(payload_size)?, align);
TypeMetadata {
path: type_.path.clone(),
origin: TypeOrigin::Lehit,
size,
align,
native_pass_mode: None,
kind: TypeMetadataKind::Enum {
tag_offset: 0,
tag_bits,
variants: lowered
.into_iter()
.map(|(index, name, payload_type)| EnumVariantMetadata {
index,
name,
tag: index as u128,
matching_tags: vec![index as u128],
fallback: false,
writes_tag: true,
payload_offset: payload_type.as_ref().map(|_| payload_offset),
payload_type,
})
.collect(),
},
}
};
self.specializations.push((type_.clone(), metadata.clone()));
Some(metadata)
}
fn layout_named(&mut self, path: &CanonicalSymbolPath) -> Option<TypeMetadata> {
if let Some(metadata) = self.metadata.get(path) {
return Some(metadata.clone());
}
if let Some(metadata) = primitive_metadata(path) {
self.metadata.insert(path.clone(), metadata.clone());
return Some(metadata);
}
if !self.active.insert(path.clone()) {
self.errors
.push(TypeMetadataError::RecursiveByValue(path.clone()));
return None;
}
let result = if let Some(native) = self.native_types.get(path) {
if !valid_native_layout(native.layout) {
let reason = native_layout_error_kind(native.layout);
self.errors.push(TypeMetadataError::InvalidNativeLayout {
path: path.clone(),
span: self.drafts.get(path).map(LayoutDraft::span),
variant_span: self.native_variant_span(path, native, &reason),
reason,
});
None
} else if !valid_native_pass_mode(&native.pass_mode, native.layout.size) {
self.errors
.push(TypeMetadataError::InvalidNativePassMode(path.clone()));
None
} else {
let kind = match self.drafts.get(path).cloned() {
Some(LayoutDraft::Structure(draft)) => TypeMetadataKind::Structure {
fields: self.native_fields(path, &draft, native)?,
},
Some(LayoutDraft::Enum(draft)) => {
self.native_enum_kind(path, &draft, native)?
}
None => TypeMetadataKind::Native,
};
Some(TypeMetadata {
path: path.clone(),
origin: TypeOrigin::Rust,
size: native.layout.size,
align: native.layout.align,
native_pass_mode: Some(native.pass_mode.clone()),
kind,
})
}
} else if let Some(draft) = self.drafts.get(path).cloned() {
match draft {
LayoutDraft::Structure(draft) => self.layout_structure(path, &draft),
LayoutDraft::Enum(draft) => self.layout_enum(path, &draft),
}
} else {
self.errors
.push(TypeMetadataError::UnknownLayout(path.clone()));
None
};
self.active.remove(path);
if let Some(metadata) = &result {
self.metadata.insert(path.clone(), metadata.clone());
}
result
}
fn native_variant_span(
&self,
path: &CanonicalSymbolPath,
native: &NativeTypeRegistration,
reason: &NativeLayoutErrorKind,
) -> Option<crate::parsing::Span> {
let index = match reason {
NativeLayoutErrorKind::DuplicateVariantIndex { index } => *index,
NativeLayoutErrorKind::InvalidPayload {
variant: Some(index),
..
} => *index,
_ => return None,
};
let registration = native
.exported_variants
.iter()
.find(|variant| variant.index == index)?;
let LayoutDraft::Enum(draft) = self.drafts.get(path)? else {
return None;
};
let file = self.files.get(&draft.file_path)?;
draft.variants.iter().find_map(|variant| {
let name = file.data.strings.get(variant.ident.string.0 as usize)?;
(name == ®istration.ident).then_some(variant.span)
})
}
fn native_enum_kind(
&mut self,
path: &CanonicalSymbolPath,
draft: &EnumDraft,
native: &NativeTypeRegistration,
) -> Option<TypeMetadataKind> {
let crate::runtime::NativeTypeKind::Enum(layout) = &native.layout.kind else {
self.errors.push(TypeMetadataError::InvalidNativeLayout {
path: path.clone(),
span: Some(draft.span),
variant_span: None,
reason: NativeLayoutErrorKind::InvalidPayload {
variant: None,
offset: None,
layout_size: native.layout.size,
},
});
return None;
};
let (offset, bits) = match &layout.tag {
crate::runtime::NativeEnumTag::Direct {
offset,
bits,
variant_tags,
..
} => {
if variant_tags.len() != layout.variants.len() {
self.errors.push(TypeMetadataError::InvalidNativeLayout {
path: path.clone(),
span: Some(draft.span),
variant_span: None,
reason: NativeLayoutErrorKind::TagCountMismatch,
});
return None;
}
(*offset, *bits)
}
crate::runtime::NativeEnumTag::Niche { offset, bits, .. } => (*offset, *bits),
crate::runtime::NativeEnumTag::SingleVariant => (0, 8),
};
let file = self.files.get(&draft.file_path)?;
let lowerer = TypeLowerer::new(self.graph, file, &draft.module);
let mut variants = Vec::with_capacity(draft.variants.len());
for declaration in &draft.variants {
let name = file
.data
.strings
.get(declaration.ident.string.0 as usize)?
.clone();
let registration = native
.exported_variants
.iter()
.find(|variant| variant.ident == name)?;
let native_position = layout
.variants
.iter()
.position(|variant| variant.index == registration.index)?;
let native_variant = &layout.variants[native_position];
let payload_type = match &declaration.value_type {
Some(type_) => match lowerer.lower(type_) {
Ok(type_) => Some(type_),
Err(error) => {
self.errors.push(TypeMetadataError::TypeLowering {
field: format!("{}::{name}", path.local),
error,
});
return None;
}
},
None => None,
};
if payload_type.is_some() != native_variant.payload.is_some()
|| payload_type.is_some() != native_variant.payload_offset.is_some()
{
self.errors.push(TypeMetadataError::InvalidNativeLayout {
path: path.clone(),
span: Some(draft.span),
variant_span: Some(declaration.span),
reason: NativeLayoutErrorKind::InvalidPayload {
variant: Some(native_variant.index),
offset: native_variant.payload_offset,
layout_size: native.layout.size,
},
});
return None;
}
let (tag, matching_tags, fallback, writes_tag) = match &layout.tag {
crate::runtime::NativeEnumTag::Direct { variant_tags, .. } => (
variant_tags[native_position],
vec![variant_tags[native_position]],
false,
true,
),
crate::runtime::NativeEnumTag::Niche { data_variant, .. }
if registration.index == *data_variant =>
{
(0, Vec::new(), true, false)
}
crate::runtime::NativeEnumTag::Niche {
niche_start,
niche_variants,
..
} if niche_variants.contains(®istration.index) => {
let tag = niche_start
.checked_add((registration.index - *niche_variants.start()) as u128)?;
(tag, vec![tag], false, true)
}
crate::runtime::NativeEnumTag::SingleVariant => (0, Vec::new(), true, false),
_ => {
self.errors.push(TypeMetadataError::InvalidNativeLayout {
path: path.clone(),
span: Some(draft.span),
variant_span: Some(declaration.span),
reason: NativeLayoutErrorKind::InvalidNicheRange,
});
return None;
}
};
variants.push(EnumVariantMetadata {
index: registration.index,
name,
tag,
matching_tags,
fallback,
writes_tag,
payload_offset: native_variant.payload_offset,
payload_type,
});
}
Some(TypeMetadataKind::Enum {
tag_offset: offset,
tag_bits: bits,
variants,
})
}
fn native_fields(
&mut self,
path: &CanonicalSymbolPath,
draft: &StructureDraft,
native: &NativeTypeRegistration,
) -> Option<Vec<FieldMetadata>> {
let file = self.files.get(&draft.file_path)?;
let lowerer = TypeLowerer::new(self.graph, file, &draft.module);
let mut fields = Vec::with_capacity(draft.fields.len());
for field in &draft.fields {
let name = file
.data
.strings
.get(field.ident.string.0 as usize)?
.clone();
let registration = native
.exported_fields
.iter()
.find(|registration| registration.ident == name)?;
let type_ = match lowerer.lower(&field.value_type) {
Ok(type_) => type_,
Err(error) => {
self.errors.push(TypeMetadataError::TypeLowering {
field: format!("{}.{name}", path.local),
error,
});
return None;
}
};
let offset = match &native.layout.kind {
crate::runtime::NativeTypeKind::Structure { fields } => fields
.iter()
.find(|field| field.index == registration.index)
.map(|field| field.offset)?,
_ => return None,
};
fields.push(FieldMetadata {
index: registration.index,
name,
public: registration.pub_visible,
offset,
type_,
});
}
Some(fields)
}
fn layout_structure(
&mut self,
path: &CanonicalSymbolPath,
draft: &StructureDraft,
) -> Option<TypeMetadata> {
let file = self.files.get(&draft.file_path)?;
let lowerer = TypeLowerer::new(self.graph, file, &draft.module);
let mut offset = 0usize;
let mut structure_align = 1usize;
let mut fields = Vec::new();
for (index, field) in draft.fields.iter().enumerate() {
let name = file
.data
.strings
.get(field.ident.string.0 as usize)?
.clone();
let type_ = match lowerer.lower(&field.value_type) {
Ok(type_) => type_,
Err(error) => {
self.errors.push(TypeMetadataError::TypeLowering {
field: format!("{}.{name}", path.local),
error,
});
return None;
}
};
let (size, align) = match self.layout_type(&type_) {
Some(layout) => layout,
None => return None,
};
offset = align_up(offset, align);
fields.push(FieldMetadata {
index: index as u32,
name,
public: field.pub_visible.is_some(),
offset,
type_,
});
offset = offset.checked_add(size)?;
structure_align = structure_align.max(align);
}
Some(TypeMetadata {
path: path.clone(),
origin: TypeOrigin::Lehit,
size: align_up(offset, structure_align),
align: structure_align,
native_pass_mode: None,
kind: TypeMetadataKind::Structure { fields },
})
}
fn layout_enum(
&mut self,
path: &CanonicalSymbolPath,
draft: &EnumDraft,
) -> Option<TypeMetadata> {
let file = self.files.get(&draft.file_path)?;
let lowerer = TypeLowerer::new(self.graph, file, &draft.module);
let mut lowered = Vec::with_capacity(draft.variants.len());
let mut payload_size = 0usize;
let mut payload_align = 1usize;
for (index, variant) in draft.variants.iter().enumerate() {
let name = file
.data
.strings
.get(variant.ident.string.0 as usize)?
.clone();
let payload_type = match &variant.value_type {
Some(value_type) => match lowerer.lower(value_type) {
Ok(type_) => Some(type_),
Err(error) => {
self.errors.push(TypeMetadataError::TypeLowering {
field: format!("{}::{name}", path.local),
error,
});
return None;
}
},
None => None,
};
if let Some(type_) = &payload_type {
let (size, align) = self.layout_type(type_)?;
payload_size = payload_size.max(size);
payload_align = payload_align.max(align);
}
lowered.push((index as u32, name, payload_type));
}
if let [(index, name, payload_type)] = lowered.as_slice() {
let (size, align, payload_offset) = if payload_type.is_some() {
(payload_size, payload_align, Some(0))
} else {
(0, 1, None)
};
return Some(TypeMetadata {
path: path.clone(),
origin: TypeOrigin::Lehit,
size,
align,
native_pass_mode: None,
kind: TypeMetadataKind::Enum {
tag_offset: 0,
tag_bits: 8,
variants: vec![EnumVariantMetadata {
index: *index,
name: name.clone(),
tag: 0,
matching_tags: Vec::new(),
fallback: true,
writes_tag: false,
payload_offset,
payload_type: payload_type.clone(),
}],
},
});
}
let payload_positions = lowered
.iter()
.enumerate()
.filter_map(|(index, (_, _, payload))| payload.as_ref().map(|_| index))
.collect::<Vec<_>>();
if !payload_positions.is_empty() {
let mut occupied = BTreeSet::new();
let mut nested_tags = vec![None; lowered.len()];
let mut common_layout = None;
let mut compatible = true;
for position in &payload_positions {
let Some(SemanticType::Named(nested)) = &lowered[*position].2 else {
compatible = false;
break;
};
if !nested.generic_arguments.is_empty() {
compatible = false;
break;
}
let Some(mut metadata) = self.layout_named(&nested.path) else {
compatible = false;
break;
};
let TypeMetadataKind::Enum {
tag_offset: 0,
tag_bits,
variants,
} = &metadata.kind
else {
compatible = false;
break;
};
let tag_bits = *tag_bits;
let layout = (metadata.size, metadata.align, tag_bits);
if common_layout.is_some_and(|common| common != layout) {
compatible = false;
break;
}
common_layout = Some(layout);
let mut tags = variants
.iter()
.flat_map(|variant| variant.matching_tags.iter().copied())
.collect::<Vec<_>>();
if tags.is_empty() {
compatible = false;
break;
}
if tags.iter().any(|tag| occupied.contains(tag)) {
let can_rebase = metadata.origin == TypeOrigin::Lehit
&& variants.iter().all(|variant| {
variant.payload_type.is_none() && variant.matching_tags.len() == 1
});
let maximum = match tag_bits {
8 => u8::MAX as u128,
16 => u16::MAX as u128,
32 => u32::MAX as u128,
64 => u64::MAX as u128,
_ => 0,
};
let mut replacement = Vec::with_capacity(variants.len());
let mut candidate = 0u128;
while can_rebase && replacement.len() < variants.len() && candidate <= maximum {
if !occupied.contains(&candidate) {
replacement.push(candidate);
}
let Some(next) = candidate.checked_add(1) else {
break;
};
candidate = next;
}
if replacement.len() != variants.len() {
compatible = false;
break;
}
let TypeMetadataKind::Enum { variants, .. } = &mut metadata.kind else {
unreachable!()
};
for (variant, tag) in variants.iter_mut().zip(&replacement) {
variant.tag = *tag;
variant.matching_tags = vec![*tag];
}
tags = replacement;
self.metadata.insert(nested.path.clone(), metadata);
}
occupied.extend(tags.iter().copied());
nested_tags[*position] = Some(tags);
}
if compatible && let Some((nested_size, nested_align, tag_bits)) = common_layout {
let maximum = match tag_bits {
8 => u8::MAX as u128,
16 => u16::MAX as u128,
32 => u32::MAX as u128,
64 => u64::MAX as u128,
_ => 0,
};
let unit_count = lowered.len().saturating_sub(payload_positions.len());
let mut free = Vec::with_capacity(unit_count);
let mut candidate = 0u128;
while free.len() < unit_count && candidate <= maximum {
if occupied.insert(candidate) {
free.push(candidate);
}
let Some(next) = candidate.checked_add(1) else {
break;
};
candidate = next;
}
if free.len() == unit_count {
let mut next_unit = 0usize;
let variants = lowered
.into_iter()
.enumerate()
.map(|(position, (index, name, payload_type))| {
if let Some(tags) = nested_tags[position].take() {
EnumVariantMetadata {
index,
name,
tag: tags[0],
matching_tags: tags,
fallback: false,
writes_tag: true,
payload_offset: Some(0),
payload_type,
}
} else {
let tag = free[next_unit];
next_unit += 1;
EnumVariantMetadata {
index,
name,
tag,
matching_tags: vec![tag],
fallback: false,
writes_tag: true,
payload_offset: None,
payload_type: None,
}
}
})
.collect();
return Some(TypeMetadata {
path: path.clone(),
origin: TypeOrigin::Lehit,
size: nested_size,
align: nested_align,
native_pass_mode: None,
kind: TypeMetadataKind::Enum {
tag_offset: 0,
tag_bits,
variants,
},
});
}
}
}
let (tag_bits, tag_size, tag_align) = match draft.variants.len() {
0..=256 => (8, std::mem::size_of::<u8>(), std::mem::align_of::<u8>()),
257..=65_536 => (16, std::mem::size_of::<u16>(), std::mem::align_of::<u16>()),
65_537..=4_294_967_296 => (32, std::mem::size_of::<u32>(), std::mem::align_of::<u32>()),
_ => (64, std::mem::size_of::<u64>(), std::mem::align_of::<u64>()),
};
let enum_align = tag_align.max(payload_align);
let payload_offset = align_up(tag_size, payload_align);
let size = align_up(payload_offset.checked_add(payload_size)?, enum_align);
let variants = lowered
.into_iter()
.map(|(index, name, payload_type)| EnumVariantMetadata {
index,
name,
tag: index as u128,
matching_tags: vec![index as u128],
fallback: false,
writes_tag: true,
payload_offset: payload_type.as_ref().map(|_| payload_offset),
payload_type,
})
.collect();
Some(TypeMetadata {
path: path.clone(),
origin: TypeOrigin::Lehit,
size,
align: enum_align,
native_pass_mode: None,
kind: TypeMetadataKind::Enum {
tag_offset: 0,
tag_bits,
variants,
},
})
}
fn layout_type(&mut self, type_: &SemanticType) -> Option<(usize, usize)> {
match type_ {
SemanticType::Void => Some((0, 1)),
SemanticType::Named(SemanticNamedType {
path,
generic_arguments,
}) if generic_arguments.is_empty() => {
self.layout_named(path).map(|m| (m.size, m.align))
}
SemanticType::Named(named)
if named.path.module == crate::core_lib::BOX_MODULE_FILE_PATH
&& named.path.local == "Box"
&& named.generic_arguments.len() == 1 =>
{
Some((std::mem::size_of::<usize>(), std::mem::align_of::<usize>()))
}
SemanticType::Named(named) => self
.specializations
.iter()
.find_map(|(key, metadata)| {
(key == named).then_some((metadata.size, metadata.align))
})
.or_else(|| {
self.errors
.push(TypeMetadataError::UnknownLayout(named.path.clone()));
None
}),
SemanticType::Reference { .. } | SemanticType::Pointer { .. } => {
Some((std::mem::size_of::<usize>(), std::mem::align_of::<usize>()))
}
SemanticType::Array {
item,
size: Some(size),
} => {
let (item_size, item_align) = self.layout_type(item)?;
Some((
align_up(item_size, item_align).checked_mul(*size)?,
item_align,
))
}
SemanticType::Tuple(items) => {
let mut offset = 0;
let mut align = 1;
for item in items {
let (size, item_align) = self.layout_type(item)?;
offset = align_up(offset, item_align).checked_add(size)?;
align = align.max(item_align);
}
Some((align_up(offset, align), align))
}
_ => {
if let SemanticType::Named(named) = type_ {
self.errors
.push(TypeMetadataError::UnknownLayout(named.path.clone()));
}
None
}
}
}
}
fn type_has_zero_niche(type_: &SemanticType) -> bool {
match type_ {
SemanticType::Reference { .. } => true,
SemanticType::Named(named) => {
(named.path.module == crate::core_lib::BOX_MODULE_FILE_PATH
&& named.path.local == "Box")
|| (named.path.module == crate::core_lib::NON_ZERO_MODULE_FILE_PATH
&& named.path.local == "NonZero")
}
_ => false,
}
}
fn primitive_metadata(path: &CanonicalSymbolPath) -> Option<TypeMetadata> {
if path.module != crate::core_lib::PRIMITIVE_MODULE_FILE_PATH {
return None;
}
let (size, align, signed) = match path.local.as_str() {
"bool" | "u8" => (1, 1, false),
"i8" => (1, 1, true),
"u16" => (2, 2, false),
"i16" => (2, 2, true),
"u32" => (4, 4, false),
"i32" => (4, 4, true),
"u64" => (8, 8, false),
"i64" => (8, 8, true),
"usize" => (
std::mem::size_of::<usize>(),
std::mem::align_of::<usize>(),
false,
),
"isize" => (
std::mem::size_of::<isize>(),
std::mem::align_of::<isize>(),
true,
),
"f32" => (4, 4, true),
"f64" => (8, 8, true),
_ => return None,
};
Some(TypeMetadata {
path: path.clone(),
origin: TypeOrigin::CompilerPrimitive,
size,
align,
native_pass_mode: None,
kind: TypeMetadataKind::Scalar {
bits: (size * 8) as u16,
signed,
},
})
}
fn native_layout_error_kind(layout: &crate::runtime::NativeTypeLayout) -> NativeLayoutErrorKind {
if layout.align == 0 || !layout.align.is_power_of_two() || layout.size % layout.align != 0 {
return NativeLayoutErrorKind::InvalidAlignment;
}
match &layout.kind {
crate::runtime::NativeTypeKind::Scalar { .. } => NativeLayoutErrorKind::InvalidScalar,
crate::runtime::NativeTypeKind::Structure { .. } => NativeLayoutErrorKind::InvalidStructure,
crate::runtime::NativeTypeKind::Enum(enum_) if enum_.variants.is_empty() => {
NativeLayoutErrorKind::EmptyEnum
}
crate::runtime::NativeTypeKind::Enum(enum_) => {
let mut indices = BTreeSet::new();
for variant in &enum_.variants {
if !indices.insert(variant.index) {
return NativeLayoutErrorKind::DuplicateVariantIndex {
index: variant.index,
};
}
if !matches!(
(variant.payload, variant.payload_offset),
(None, None) | (Some(_), Some(_))
) {
return NativeLayoutErrorKind::InvalidPayload {
variant: Some(variant.index),
offset: variant.payload_offset,
layout_size: layout.size,
};
}
}
match &enum_.tag {
crate::runtime::NativeEnumTag::Direct {
offset,
bits,
variant_tags,
..
} => {
if variant_tags.len() != enum_.variants.len() {
NativeLayoutErrorKind::TagCountMismatch
} else {
let mut tags = BTreeSet::new();
if let Some(tag) = variant_tags.iter().find(|tag| !tags.insert(**tag)) {
NativeLayoutErrorKind::DuplicateTag { tag: *tag }
} else if !matches!(bits, 8 | 16 | 32 | 64)
|| offset
.checked_add(usize::from(*bits / 8))
.is_none_or(|end| end > layout.size)
{
NativeLayoutErrorKind::InvalidTagStorage {
offset: *offset,
bits: *bits,
layout_size: layout.size,
}
} else {
let tag = variant_tags
.iter()
.copied()
.find(|tag| *tag >= (1u128 << *bits))
.unwrap_or(0);
NativeLayoutErrorKind::TagOutOfRange { tag, bits: *bits }
}
}
}
crate::runtime::NativeEnumTag::Niche {
data_variant,
niche_variants,
..
} => {
if !indices.contains(data_variant) || niche_variants.contains(data_variant) {
NativeLayoutErrorKind::InvalidNicheDataVariant
} else {
NativeLayoutErrorKind::InvalidNicheRange
}
}
crate::runtime::NativeEnumTag::SingleVariant => {
NativeLayoutErrorKind::InvalidSingleVariant
}
}
}
crate::runtime::NativeTypeKind::Bytes | crate::runtime::NativeTypeKind::Opaque => {
NativeLayoutErrorKind::InvalidAlignment
}
}
}
fn valid_native_layout(layout: &crate::runtime::NativeTypeLayout) -> bool {
if layout.align == 0 || !layout.align.is_power_of_two() || layout.size % layout.align != 0 {
return false;
}
match &layout.kind {
crate::runtime::NativeTypeKind::Scalar { bits, .. } => {
matches!(bits, 8 | 16 | 32 | 64 | 128) && usize::from(*bits / 8) == layout.size
}
crate::runtime::NativeTypeKind::Bytes | crate::runtime::NativeTypeKind::Opaque => true,
crate::runtime::NativeTypeKind::Structure { fields } => {
let mut indices = BTreeSet::new();
fields.iter().all(|field| {
indices.insert(field.index)
&& valid_native_layout(field.layout)
&& field.offset % field.layout.align == 0
&& field
.offset
.checked_add(field.layout.size)
.is_some_and(|end| end <= layout.size)
})
}
crate::runtime::NativeTypeKind::Enum(enum_) => {
let mut indices = BTreeSet::new();
if enum_.variants.is_empty()
|| !enum_.variants.iter().all(|variant| {
indices.insert(variant.index)
&& match (variant.payload, variant.payload_offset) {
(None, None) => true,
(Some(payload), Some(offset)) => {
valid_native_layout(payload)
&& offset % payload.align == 0
&& offset
.checked_add(payload.size)
.is_some_and(|end| end <= layout.size)
}
_ => false,
}
})
{
return false;
}
let valid_tag_storage = |offset: usize, bits: u16| {
matches!(bits, 8 | 16 | 32 | 64)
&& offset
.checked_add(usize::from(bits / 8))
.is_some_and(|end| end <= layout.size)
};
let fits = |value: u128, bits: u16| value < (1u128 << bits);
match &enum_.tag {
crate::runtime::NativeEnumTag::Direct {
offset,
bits,
variant_tags,
..
} => {
let mut tags = BTreeSet::new();
valid_tag_storage(*offset, *bits)
&& variant_tags.len() == enum_.variants.len()
&& variant_tags
.iter()
.all(|tag| fits(*tag, *bits) && tags.insert(*tag))
}
crate::runtime::NativeEnumTag::Niche {
offset,
bits,
niche_start,
niche_variants,
data_variant,
} => {
let start = *niche_variants.start();
let end = *niche_variants.end();
let count = end
.checked_sub(start)
.and_then(|count| count.checked_add(1));
valid_tag_storage(*offset, *bits)
&& start <= end
&& indices.contains(data_variant)
&& !niche_variants.contains(data_variant)
&& count.is_some_and(|count| {
enum_
.variants
.iter()
.filter(|variant| niche_variants.contains(&variant.index))
.count()
== count as usize
&& niche_start
.checked_add(u128::from(count - 1))
.is_some_and(|last| fits(last, *bits))
})
}
crate::runtime::NativeEnumTag::SingleVariant => enum_.variants.len() == 1,
}
}
}
}
fn valid_native_pass_mode(mode: &NativePassMode, size: usize) -> bool {
let NativePassMode::Registers(chunks) = mode else {
return true;
};
if chunks.is_empty() {
return false;
}
let mut occupied = BTreeSet::new();
chunks.iter().all(|chunk| {
let bits = match chunk.class {
NativeRegisterClass::Integer { bits } if matches!(bits, 8 | 16 | 32 | 64) => bits,
NativeRegisterClass::Float { bits } if matches!(bits, 32 | 64) => bits,
_ => return false,
};
let bytes = usize::from(bits / 8);
let Some(end) = chunk.offset.checked_add(bytes) else {
return false;
};
end <= size && (chunk.offset..end).all(|byte| occupied.insert(byte))
})
}
fn align_up(value: usize, align: usize) -> usize {
debug_assert!(align.is_power_of_two());
(value + align - 1) & !(align - 1)
}
fn layout_sequence(
registry: &TypeMetadataRegistry,
items: &[SemanticType],
) -> Option<(usize, usize)> {
let mut offset = 0usize;
let mut align = 1usize;
for item in items {
let (size, item_align) = registry.layout_of(item)?;
offset = align_up(offset, item_align).checked_add(size)?;
align = align.max(item_align);
}
Some((align_up(offset, align), align))
}
#[cfg(test)]
mod specialization_tests {
use super::*;
use crate::parsing::{SourceFile, parse_file};
use crate::semantic::{DeclarationIndex, SemanticGenericArgument};
#[test]
fn generic_templates_do_not_create_an_unspecialized_layout() {
let path = "app://generic-layout.lt";
let parsed = parse_file(SourceFile {
path,
text: "pub acs Wrapper<T>: struct { pub fld value: T }",
})
.unwrap();
let mut graph = ModuleGraph::default();
graph
.insert(path, DeclarationIndex::collect(&parsed).unwrap())
.unwrap();
let registry = TypeMetadataRegistry::build(
&graph,
&BTreeMap::from([(path.to_owned(), parsed)]),
&BTreeMap::new(),
)
.unwrap();
let wrapper_path = CanonicalSymbolPath {
module: path.into(),
local: "Wrapper".into(),
};
assert!(registry.get(&wrapper_path).is_none());
let wrapper_u32 = SemanticNamedType {
path: wrapper_path,
generic_arguments: vec![SemanticGenericArgument::Type(SemanticType::Named(
SemanticNamedType {
path: CanonicalSymbolPath {
module: crate::core_lib::PRIMITIVE_MODULE_FILE_PATH.into(),
local: "u32".into(),
},
generic_arguments: Vec::new(),
},
))],
};
let parsed = parse_file(SourceFile {
path,
text: "pub acs Wrapper<T>: struct { pub fld value: T }",
})
.unwrap();
let specialized = TypeMetadataRegistry::build_with_specializations(
&graph,
&BTreeMap::from([(path.to_owned(), parsed)]),
&BTreeMap::new(),
&[(wrapper_u32.clone(), path.to_owned())],
)
.unwrap();
let metadata = specialized.get_named(&wrapper_u32).unwrap();
assert_eq!((metadata.size, metadata.align), (4, 4));
assert!(matches!(
&metadata.kind,
TypeMetadataKind::Structure { fields }
if fields.len() == 1 && fields[0].offset == 0
));
}
#[test]
fn specializes_a_generic_enum_with_a_concrete_payload_layout() {
let path = "app://generic-enum.lt";
let parsed = parse_file(SourceFile {
path,
text: "pub acs Option<T>: enum { var None var Some T }",
})
.unwrap();
let mut graph = ModuleGraph::default();
graph
.insert(path, DeclarationIndex::collect(&parsed).unwrap())
.unwrap();
let option_u64 = SemanticNamedType {
path: CanonicalSymbolPath {
module: path.into(),
local: "Option".into(),
},
generic_arguments: vec![SemanticGenericArgument::Type(SemanticType::Named(
SemanticNamedType {
path: CanonicalSymbolPath {
module: crate::core_lib::PRIMITIVE_MODULE_FILE_PATH.into(),
local: "u64".into(),
},
generic_arguments: Vec::new(),
},
))],
};
let registry = TypeMetadataRegistry::build_with_specializations(
&graph,
&BTreeMap::from([(path.to_owned(), parsed)]),
&BTreeMap::new(),
&[(option_u64.clone(), path.to_owned())],
)
.unwrap();
let metadata = registry.get_named(&option_u64).unwrap();
assert_eq!((metadata.size, metadata.align), (16, 8));
assert!(matches!(
&metadata.kind,
TypeMetadataKind::Enum { variants, tag_bits: 8, .. }
if variants[0].payload_offset.is_none()
&& variants[1].payload_offset == Some(8)
&& matches!(variants[1].payload_type, Some(SemanticType::Named(_)))
));
}
#[test]
fn core_option_uses_zero_niches_for_box_and_non_zero_payloads() {
let mut graph = ModuleGraph::default();
let mut files = BTreeMap::new();
for (path, script) in crate::core_lib::generate_core_lib().scripts {
let parsed = parse_file(SourceFile {
path: &path,
text: &script.content,
})
.unwrap();
graph
.insert(&path, DeclarationIndex::collect(&parsed).unwrap())
.unwrap();
files.insert(path, parsed);
}
graph
.set_prelude(crate::core_lib::PRELUDE_MODULE_FILE_PATH)
.unwrap();
let app_path = "app://niche.lt";
let app = parse_file(SourceFile {
path: app_path,
text: "",
})
.unwrap();
graph
.insert(app_path, DeclarationIndex::collect(&app).unwrap())
.unwrap();
files.insert(app_path.into(), app);
let u32_type = SemanticType::Named(SemanticNamedType {
path: CanonicalSymbolPath {
module: crate::core_lib::PRIMITIVE_MODULE_FILE_PATH.into(),
local: "u32".into(),
},
generic_arguments: Vec::new(),
});
let specialized = |name: &str, argument: SemanticType| SemanticNamedType {
path: CanonicalSymbolPath {
module: match name {
"Option" => crate::core_lib::OPTION_MODULE_FILE_PATH,
"Box" => crate::core_lib::BOX_MODULE_FILE_PATH,
"NonZero" => crate::core_lib::NON_ZERO_MODULE_FILE_PATH,
_ => unreachable!("unexpected core container type"),
}
.into(),
local: name.into(),
},
generic_arguments: vec![SemanticGenericArgument::Type(argument)],
};
let box_u32 = specialized("Box", u32_type.clone());
let non_zero_u32 = specialized("NonZero", u32_type);
let option_box = specialized("Option", SemanticType::Named(box_u32.clone()));
let option_non_zero = specialized("Option", SemanticType::Named(non_zero_u32.clone()));
let requests = vec![
(box_u32, app_path.into()),
(non_zero_u32, app_path.into()),
(option_box.clone(), app_path.into()),
(option_non_zero.clone(), app_path.into()),
];
let registry = TypeMetadataRegistry::build_with_specializations(
&graph,
&files,
&BTreeMap::new(),
&requests,
)
.unwrap();
for (type_, expected_layout) in [(option_box, (8, 8)), (option_non_zero, (4, 4))] {
let metadata = registry.get_named(&type_).unwrap();
assert_eq!((metadata.size, metadata.align), expected_layout);
let TypeMetadataKind::Enum {
tag_offset,
variants,
..
} = &metadata.kind
else {
panic!("Option specialization must be an enum")
};
assert_eq!(*tag_offset, 0);
let none = variants
.iter()
.find(|variant| variant.name == "None")
.unwrap();
let some = variants
.iter()
.find(|variant| variant.name == "Some")
.unwrap();
assert_eq!(none.matching_tags, [0]);
assert!(none.writes_tag);
assert_eq!(none.payload_offset, None);
assert!(some.fallback);
assert!(!some.writes_tag);
assert_eq!(some.payload_offset, Some(0));
}
}
#[test]
fn generic_metadata_is_keyed_by_concrete_arguments() {
let generic_path = CanonicalSymbolPath {
module: "core://option.lt".into(),
local: "Option".into(),
};
let primitive = |name: &str| {
SemanticType::Named(SemanticNamedType {
path: CanonicalSymbolPath {
module: crate::core_lib::PRIMITIVE_MODULE_FILE_PATH.into(),
local: name.into(),
},
generic_arguments: Vec::new(),
})
};
let specialized = |argument| SemanticNamedType {
path: generic_path.clone(),
generic_arguments: vec![SemanticGenericArgument::Type(argument)],
};
let option_u32 = specialized(primitive("u32"));
let option_u64 = specialized(primitive("u64"));
let metadata = |size, align| TypeMetadata {
path: generic_path.clone(),
origin: TypeOrigin::Lehit,
size,
align,
native_pass_mode: None,
kind: TypeMetadataKind::Native,
};
let mut registry = TypeMetadataRegistry::default();
registry.insert_specialization(option_u32.clone(), metadata(4, 4));
registry.insert_specialization(option_u64.clone(), metadata(8, 8));
assert_eq!(
registry.get_named(&option_u32).map(|item| item.size),
Some(4)
);
assert_eq!(
registry.get_named(&option_u64).map(|item| item.size),
Some(8)
);
assert!(registry.get(&generic_path).is_none());
}
}