use std::collections::BTreeMap;
use std::error::Error;
use std::fmt;
use crate::parsing::{
ParsedFile,
ast::{
ContractAccessPath, ContractDeclarationKind, ContractDefinitionContent, ContractSource,
FunctionContractDeclaration, GenericDeclarationList,
},
};
use crate::semantic::{
CanonicalSymbolPath, CollectedAliasArgument, CollectedGenericParameter, CollectedSymbolKind,
ModuleGraph, SemanticFunctionType, SemanticGenericParameter, TypeLowerer, TypeLoweringError,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct GlobalFunctionId(pub u32);
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GlobalFunction {
pub id: GlobalFunctionId,
pub path: CanonicalSymbolPath,
pub public: bool,
pub generic_parameters: Vec<SemanticGenericParameter>,
pub signature: SemanticFunctionType,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FunctionAlias {
pub path: CanonicalSymbolPath,
pub parameters: Vec<CollectedGenericParameter>,
pub target: GlobalFunctionId,
pub target_arguments: Vec<CollectedAliasArgument>,
}
#[derive(Debug, Clone, Default)]
pub struct FunctionRegistry {
functions: Vec<GlobalFunction>,
function_ids: BTreeMap<CanonicalSymbolPath, GlobalFunctionId>,
aliases: BTreeMap<CanonicalSymbolPath, FunctionAlias>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FunctionRegistryError {
MissingParsedModule {
path: String,
},
InvalidStringId {
module: String,
id: u32,
},
TypeLowering {
function: CanonicalSymbolPath,
error: TypeLoweringError,
},
MissingAliasTarget {
alias: CanonicalSymbolPath,
target: CanonicalSymbolPath,
},
}
impl fmt::Display for FunctionRegistryError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::MissingParsedModule { path } => {
write!(formatter, "missing parsed AST for module `{path}`")
}
Self::InvalidStringId { module, id } => {
write!(
formatter,
"module `{module}` contains invalid StringId({id})"
)
}
Self::TypeLowering { function, error } => write!(
formatter,
"cannot lower signature of `{}::{}`: {error}",
function.module, function.local
),
Self::MissingAliasTarget { alias, target } => write!(
formatter,
"function alias `{}::{}` targets unregistered function `{}::{}`",
alias.module, alias.local, target.module, target.local
),
}
}
}
impl Error for FunctionRegistryError {}
impl FunctionRegistry {
pub fn build(
graph: &ModuleGraph,
files: &BTreeMap<String, ParsedFile>,
) -> Result<Self, Vec<FunctionRegistryError>> {
let mut drafts = BTreeMap::<CanonicalSymbolPath, FunctionDraft<'_>>::new();
let mut errors = Vec::new();
for module in graph.modules() {
let Some(file) = files.get(&module.path) else {
errors.push(FunctionRegistryError::MissingParsedModule {
path: module.path.clone(),
});
continue;
};
collect_content(
file,
&module.path,
"",
&file.ast.contract_definition_content,
&mut drafts,
&mut errors,
);
}
if !errors.is_empty() {
return Err(errors);
}
let mut registry = Self::default();
for (index, (path, draft)) in drafts.into_iter().enumerate() {
let lowerer = match TypeLowerer::new(graph, draft.file, &path.module)
.with_generic_parameters(draft.generics)
{
Ok(lowerer) => lowerer,
Err(error) => {
errors.push(FunctionRegistryError::TypeLowering {
function: path,
error,
});
continue;
}
};
match lowerer.lower_function(draft.function) {
Ok(signature) => {
let id = GlobalFunctionId(
u32::try_from(index).expect("function count exceeds GlobalFunctionId"),
);
registry.function_ids.insert(path.clone(), id);
registry.functions.push(GlobalFunction {
id,
path: path.clone(),
public: draft.public,
generic_parameters: lowerer.generic_parameters(),
signature,
});
}
Err(error) => errors.push(FunctionRegistryError::TypeLowering {
function: path,
error,
}),
}
}
if !errors.is_empty() {
return Err(errors);
}
for module in graph.modules() {
for symbol in module.declarations.symbols.values() {
let CollectedSymbolKind::Alias { parameters, target } = &symbol.kind else {
continue;
};
let Ok(resolved) = graph.resolve(&module.path, &symbol.path) else {
continue;
};
let target_path = CanonicalSymbolPath {
module: resolved.module_path.to_owned(),
local: resolved.local_path.to_owned(),
};
let Some(&target_id) = registry.function_ids.get(&target_path) else {
continue;
};
let alias_path = CanonicalSymbolPath {
module: module.path.clone(),
local: symbol.path.clone(),
};
registry.aliases.insert(
alias_path.clone(),
FunctionAlias {
path: alias_path,
parameters: parameters.clone(),
target: target_id,
target_arguments: target.arguments.clone(),
},
);
}
}
Ok(registry)
}
pub(crate) fn insert_synthetic(
&mut self,
path: CanonicalSymbolPath,
signature: SemanticFunctionType,
) -> GlobalFunctionId {
if let Some(id) = self.function_ids.get(&path) {
return *id;
}
let id = GlobalFunctionId(
u32::try_from(self.functions.len()).expect("function count exceeds GlobalFunctionId"),
);
self.function_ids.insert(path.clone(), id);
self.functions.push(GlobalFunction {
id,
path,
public: false,
generic_parameters: Vec::new(),
signature,
});
id
}
pub fn iter(&self) -> impl Iterator<Item = &GlobalFunction> {
self.functions.iter()
}
pub fn function(&self, id: GlobalFunctionId) -> Option<&GlobalFunction> {
self.functions.get(id.0 as usize)
}
pub fn function_by_path(&self, path: &CanonicalSymbolPath) -> Option<&GlobalFunction> {
self.function_ids
.get(path)
.and_then(|id| self.function(*id))
}
pub fn alias(&self, path: &CanonicalSymbolPath) -> Option<&FunctionAlias> {
self.aliases.get(path)
}
pub fn function_id(&self, path: &CanonicalSymbolPath) -> Option<GlobalFunctionId> {
self.function_ids.get(path).copied()
}
pub fn len(&self) -> usize {
self.functions.len()
}
pub fn is_empty(&self) -> bool {
self.functions.is_empty()
}
}
struct FunctionDraft<'a> {
file: &'a ParsedFile,
function: &'a FunctionContractDeclaration,
generics: Option<&'a GenericDeclarationList>,
public: bool,
}
fn collect_content<'a>(
file: &'a ParsedFile,
module: &str,
prefix: &str,
content: &'a ContractDefinitionContent,
drafts: &mut BTreeMap<CanonicalSymbolPath, FunctionDraft<'a>>,
errors: &mut Vec<FunctionRegistryError>,
) {
for access in &content.contract_accesses {
let Some(name) = string(file, module, access.ident.string.0, errors) else {
continue;
};
let local_path = join_path(prefix, name);
match &access.source {
ContractSource::Declaration(declaration) => {
let function = match &declaration.kind {
ContractDeclarationKind::FunctionOnly(function) => Some(function.as_ref()),
ContractDeclarationKind::FunctionAndLayout(function) => {
Some(&function.function)
}
_ => None,
};
if let Some(function) = function {
drafts.insert(
CanonicalSymbolPath {
module: module.to_owned(),
local: local_path.clone(),
},
FunctionDraft {
file,
function,
generics: access.generic_declaration_list.as_ref(),
public: access.pub_visible.is_some(),
},
);
}
if let Some(definition) = &declaration.definition {
collect_content(
file,
module,
&local_path,
&definition.content,
drafts,
errors,
);
}
}
ContractSource::Definition(definition) => collect_content(
file,
module,
&local_path,
&definition.content,
drafts,
errors,
),
_ => {}
}
}
for implementation in &content.trait_implementations {
let Some(trait_path) = access_path(file, module, &implementation.trait_path, errors) else {
continue;
};
if let Some(definition) = &implementation.definition {
collect_content(
file,
module,
&join_path(prefix, &trait_path),
&definition.content,
drafts,
errors,
);
}
}
}
fn access_path(
file: &ParsedFile,
module: &str,
path: &ContractAccessPath,
errors: &mut Vec<FunctionRegistryError>,
) -> Option<String> {
let mut parts = Vec::with_capacity(path.parts.1.len() + 1);
parts.push(string(file, module, path.parts.0.ident.string.0, errors)?.to_owned());
for part in &path.parts.1 {
parts.push(string(file, module, part.ident.string.0, errors)?.to_owned());
}
Some(parts.join("."))
}
fn string<'a>(
file: &'a ParsedFile,
module: &str,
id: u32,
errors: &mut Vec<FunctionRegistryError>,
) -> Option<&'a str> {
match file.data.strings.get(id as usize) {
Some(value) => Some(value),
None => {
errors.push(FunctionRegistryError::InvalidStringId {
module: module.to_owned(),
id,
});
None
}
}
}
fn join_path(prefix: &str, name: &str) -> String {
if prefix.is_empty() {
name.to_owned()
} else {
format!("{prefix}.{name}")
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::parsing::{SourceFile, parse_file};
use crate::semantic::{DeclarationIndex, SemanticLifetime, SemanticType};
fn insert(
graph: &mut ModuleGraph,
files: &mut BTreeMap<String, ParsedFile>,
path: &str,
source: &str,
) {
let parsed = parse_file(SourceFile { path, text: source }).unwrap();
graph
.insert(path, DeclarationIndex::collect(&parsed).unwrap())
.unwrap();
files.insert(path.to_owned(), parsed);
}
fn core() -> (ModuleGraph, BTreeMap<String, ParsedFile>) {
let mut graph = ModuleGraph::default();
let mut files = BTreeMap::new();
for (path, source) in [
("core://ops.lt", crate::core_lib::OPS_MODULE_FILE_CONTENT),
("core://cmp.lt", crate::core_lib::CMP_MODULE_FILE_CONTENT),
(
"core://primitive.lt",
crate::core_lib::PRIMITIVE_MODULE_FILE_CONTENT,
),
(
"core://prelude.lt",
crate::core_lib::PRELUDE_MODULE_FILE_CONTENT,
),
] {
insert(&mut graph, &mut files, path, source);
}
graph
.set_prelude(crate::core_lib::PRELUDE_MODULE_FILE_PATH)
.unwrap();
(graph, files)
}
#[test]
fn registers_core_functions_with_deterministic_global_ids() {
let (graph, files) = core();
let first = FunctionRegistry::build(&graph, &files).unwrap();
let second = FunctionRegistry::build(&graph, &files).unwrap();
assert!(!first.is_empty());
let path = CanonicalSymbolPath {
module: "core://ops.lt".into(),
local: "Add.add".into(),
};
assert_eq!(first.function_id(&path), second.function_id(&path));
let function = first.function_by_path(&path).unwrap();
assert!(matches!(
function.signature.receiver,
Some(crate::semantic::SemanticReceiver { borrow: false, .. })
));
assert!(matches!(
function.signature.return_type.as_ref(),
SemanticType::SelfType
));
}
#[test]
fn generic_function_alias_reuses_target_id() {
let mut graph = ModuleGraph::default();
let mut files = BTreeMap::new();
insert(
&mut graph,
&mut files,
"lib://functions.lt",
"pub acs identity<'a, T>: fn(value: &'a T) -> &'a T",
);
insert(
&mut graph,
&mut files,
"app://main.lt",
"acs functions: \"lib://functions.lt\" acs identity<'a, T>: functions.identity<'a, T>",
);
let registry = FunctionRegistry::build(&graph, &files).unwrap();
assert_eq!(registry.len(), 1);
let target_path = CanonicalSymbolPath {
module: "lib://functions.lt".into(),
local: "identity".into(),
};
let target = registry.function_by_path(&target_path).unwrap();
assert_eq!(target.generic_parameters.len(), 2);
let SemanticType::Reference {
lifetime: Some(SemanticLifetime::Parameter(lifetime)),
target: return_target,
..
} = target.signature.return_type.as_ref()
else {
panic!("generic return reference expected")
};
assert_eq!(lifetime.name, "a");
assert!(
matches!(return_target.as_ref(), SemanticType::Parameter(parameter) if parameter.name == "T")
);
let alias_path = CanonicalSymbolPath {
module: "app://main.lt".into(),
local: "identity".into(),
};
let alias = registry.alias(&alias_path).unwrap();
assert_eq!(alias.target, target.id);
assert_eq!(alias.parameters.len(), 2);
}
}