mod box_type;
mod clone;
mod cmp;
mod deref;
mod drop;
mod non_zero;
mod ops;
mod option_type;
mod prelude;
mod primitive;
pub use box_type::*;
pub use clone::*;
pub use cmp::*;
pub use deref::*;
pub use drop::*;
pub use non_zero::*;
pub use ops::*;
pub use option_type::*;
pub use prelude::*;
pub use primitive::*;
use crate::rust_lib::{RustLib, Script};
#[macro_export]
macro_rules! core_namespace {
() => {
"core://"
};
}
pub use core_namespace;
pub const CORE_NAMESPACE_PATH: &str = core_namespace!();
pub fn generate_core_lib() -> RustLib {
let mut library = RustLib::default();
library.scripts.insert(
CLONE_MODULE_FILE_PATH.to_string(),
Script {
content: CLONE_MODULE_FILE_CONTENT.to_string(),
..Script::default()
},
);
library.scripts.insert(
DEREF_MODULE_FILE_PATH.to_string(),
Script {
content: DEREF_MODULE_FILE_CONTENT.to_string(),
..Script::default()
},
);
library.scripts.insert(
DROP_MODULE_FILE_PATH.to_string(),
Script {
content: DROP_MODULE_FILE_CONTENT.to_string(),
..Script::default()
},
);
library.scripts.insert(
OPS_MODULE_FILE_PATH.to_string(),
Script {
content: OPS_MODULE_FILE_CONTENT.to_string(),
..Script::default()
},
);
library.scripts.insert(
CMP_MODULE_FILE_PATH.to_string(),
Script {
content: CMP_MODULE_FILE_CONTENT.to_string(),
..Script::default()
},
);
library.scripts.insert(
PRIMITIVE_MODULE_FILE_PATH.to_string(),
generate_primitive_module(),
);
for (path, content) in [
(NON_ZERO_MODULE_FILE_PATH, NON_ZERO_MODULE_FILE_CONTENT),
(BOX_MODULE_FILE_PATH, BOX_MODULE_FILE_CONTENT),
(OPTION_MODULE_FILE_PATH, OPTION_MODULE_FILE_CONTENT),
] {
library.scripts.insert(
path.to_string(),
Script {
content: content.to_string(),
..Script::default()
},
);
}
library.scripts.insert(
PRELUDE_MODULE_FILE_PATH.to_string(),
Script {
content: PRELUDE_MODULE_FILE_CONTENT.to_string(),
..Script::default()
},
);
library
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn concrete_non_zero_aliases_expand_to_generic_specializations() {
use crate::parsing::{SourceFile, parse_file};
use crate::semantic::{DeclarationIndex, ModuleGraph, SemanticType, TypeLowerer};
let mut graph = ModuleGraph::default();
for (path, script) in generate_core_lib().scripts {
let parsed = parse_file(SourceFile {
path: &path,
text: &script.content,
})
.unwrap();
graph
.insert(&path, DeclarationIndex::collect(&parsed).unwrap())
.unwrap();
}
graph.set_prelude(PRELUDE_MODULE_FILE_PATH).unwrap();
let app_path = "app://non-zero-alias.lt";
let app = parse_file(SourceFile {
path: app_path,
text: "acs make: fn() -> NonZeroU32",
})
.unwrap();
graph
.insert(app_path, DeclarationIndex::collect(&app).unwrap())
.unwrap();
let crate::parsing::ast::ContractSource::Declaration(function) =
&app.ast.contract_definition_content.contract_accesses[0].source
else {
panic!("function declaration expected")
};
let crate::parsing::ast::ContractDeclarationKind::FunctionOnly(function) = &function.kind
else {
panic!("function contract expected")
};
let signature = TypeLowerer::new(&graph, &app, app_path)
.lower_function(function)
.unwrap();
let SemanticType::Named(named) = signature.return_type.as_ref() else {
panic!("NonZeroU32 must be a named specialization")
};
assert_eq!(named.path.module, NON_ZERO_MODULE_FILE_PATH);
assert_eq!(named.path.local, "NonZero");
assert!(matches!(
named.generic_arguments.as_slice(),
[crate::semantic::SemanticGenericArgument::Type(SemanticType::Named(argument))]
if argument.path.module == PRIMITIVE_MODULE_FILE_PATH
&& argument.path.local == "u32"
));
}
#[test]
fn generic_box_extension_substitutes_its_deref_target() {
use crate::parsing::{SourceFile, parse_file};
use crate::semantic::{
CanonicalSymbolPath, DeclarationIndex, ExtensionEnvironment, MethodTable, ModuleGraph,
SemanticGenericArgument, SemanticNamedType, SemanticType,
};
let mut graph = ModuleGraph::default();
for (path, script) in generate_core_lib().scripts {
let parsed = parse_file(SourceFile {
path: &path,
text: &script.content,
})
.unwrap();
graph
.insert(&path, DeclarationIndex::collect(&parsed).unwrap())
.unwrap();
}
graph.set_prelude(PRELUDE_MODULE_FILE_PATH).unwrap();
let app = "app://box-deref-substitution.lt";
let parsed = parse_file(SourceFile {
path: app,
text: "",
})
.unwrap();
graph
.insert(app, DeclarationIndex::collect(&parsed).unwrap())
.unwrap();
let u32_type = SemanticType::Named(SemanticNamedType {
path: CanonicalSymbolPath {
module: PRIMITIVE_MODULE_FILE_PATH.into(),
local: "u32".into(),
},
generic_arguments: Vec::new(),
});
let boxed = SemanticNamedType {
path: CanonicalSymbolPath {
module: BOX_MODULE_FILE_PATH.into(),
local: "Box".into(),
},
generic_arguments: vec![SemanticGenericArgument::Type(u32_type.clone())],
};
let environment = ExtensionEnvironment::build(&graph, app).unwrap();
let table = MethodTable::build_named(&graph, &boxed, &environment).unwrap();
let implementation = table
.trait_implementations
.iter()
.find(|implementation| implementation.associated_types.contains_key("Target"))
.unwrap();
assert_eq!(
implementation.concrete_associated_types.get("Target"),
Some(&u32_type)
);
}
#[test]
fn generated_core_library_contains_prelude() {
let library = generate_core_lib();
let prelude = library
.scripts
.get(PRELUDE_MODULE_FILE_PATH)
.expect("core prelude must be installed with RustLib");
assert_eq!(prelude.content, PRELUDE_MODULE_FILE_CONTENT);
assert!(library.scripts.contains_key(CLONE_MODULE_FILE_PATH));
assert!(library.scripts.contains_key(DEREF_MODULE_FILE_PATH));
assert!(library.scripts.contains_key(DROP_MODULE_FILE_PATH));
assert!(library.scripts.contains_key(NON_ZERO_MODULE_FILE_PATH));
assert!(library.scripts.contains_key(BOX_MODULE_FILE_PATH));
assert!(library.scripts.contains_key(OPTION_MODULE_FILE_PATH));
}
}