✨ Imports with namespacing, pub/use

Cargo.toml

@@ -33,6 +33,9 @@ arbitrary = { version = "1", optional = true, features = ["derive"] }
 clap = "4.5.37"
 chumsky = "0.11.2"
 
+[dev-dependencies]
+tempfile = "3"
+
 [target.wasm32-unknown-unknown.dependencies]
 getrandom = { version = "0.2", features = ["js"] }
 
@@ -68,7 +71,7 @@ copy_iterator = "warn"
 default_trait_access = "warn"
 doc_link_with_quotes = "warn"
 doc_markdown = "warn"
-empty_enum = "warn"
+empty_enums = "warn"
 enum_glob_use = "allow"
 expl_impl_clone_on_copy = "warn"
 explicit_deref_methods = "warn"
@@ -152,7 +155,7 @@ struct_field_names = "warn"
 too_many_lines = "allow"
 transmute_ptr_to_ptr = "warn"
 trivially_copy_pass_by_ref = "warn"
-unchecked_duration_subtraction = "warn"
+unchecked_time_subtraction = "warn"
 unicode_not_nfc = "warn"
 unnecessary_box_returns = "warn"
 unnecessary_join = "warn"

examples/multiple_libs/main.simf

@@ -0,0 +1,16 @@
+use merkle::build_root::{get_root, hash as and_hash};
+use base_math::simple_op::hash as or_hash;
+
+pub fn get_block_value_hash(prev_hash: u32, tx1: u32, tx2: u32) -> u32 {
+    let root: u32 = get_root(tx1, tx2);
+    or_hash(prev_hash, root)
+}
+
+fn main() {
+    let block_val_hash: u32 = get_block_value_hash(5, 10, 20);
+    assert!(jet::eq_32(block_val_hash, 27));
+
+    let first_value: u32 = 15;
+    let second_value: u32 = 22;
+    assert!(jet::eq_32(and_hash(first_value, second_value), 6));
+}

examples/multiple_libs/math/simple_op.simf

@@ -0,0 +1,3 @@
+pub fn hash(x: u32, y: u32) -> u32 {
+    jet::xor_32(x, y)
+}

examples/multiple_libs/merkle/build_root.simf

@@ -0,0 +1,9 @@
+use math::simple_op::hash as temp_hash;
+
+pub fn get_root(tx1: u32, tx2: u32) -> u32 {
+    temp_hash(tx1, tx2)
+}
+
+pub fn hash(tx1: u32, tx2: u32) -> u32 {
+    jet::and_32(tx1, tx2)
+}

examples/simple_multilib/crypto/hashes.simf

@@ -0,0 +1,5 @@
+pub fn sha256(data: u32) -> u256 {
+    let ctx: Ctx8 = jet::sha_256_ctx_8_init();
+    let ctx: Ctx8 = jet::sha_256_ctx_8_add_4(ctx, data);
+    jet::sha_256_ctx_8_finalize(ctx)
+}

examples/simple_multilib/main.simf

@@ -0,0 +1,7 @@
+use math::arithmetic::add;
+use crypto::hashes::sha256;
+
+fn main() {
+    let sum: u32 = add(2, 3);
+    let hash: u256 = sha256(sum);
+}

examples/simple_multilib/math/arithmetic.simf

@@ -0,0 +1,4 @@
+pub fn add(a: u32, b: u32) -> u32 {
+    let (_, res): (bool, u32) = jet::add_32(a, b);
+    res
+}

examples/single_lib/main.simf

@@ -0,0 +1,11 @@
+pub use temp::constants::utils::two as smth;
+use temp::funcs::{get_five, Smth};
+
+fn seven() -> u32 {
+    7
+}
+
+fn main() {
+    let (_, temp): (bool, u32) = jet::add_32(smth(), get_five());
+    assert!(jet::eq_32(temp, seven()));
+}

examples/single_lib/temp/constants/utils.simf

@@ -0,0 +1,5 @@
+pub use temp::funcs::Smth;
+
+pub fn two() -> Smth {
+    2
+}

examples/single_lib/temp/funcs.simf

@@ -0,0 +1,5 @@
+pub type Smth = u32;
+
+pub fn get_five() -> u32 {
+    5
+}

examples/temp/libs/lib/math.simf

@@ -0,0 +1 @@
+fn add(a: u32, b: u32) {}

examples/temp/main.simf

@@ -0,0 +1 @@
+use lib::math::add;

functional-tests/error-test-cases/cross-wire/lib/b.simf

@@ -0,0 +1,2 @@
+use lib::x::TypeX;
+use lib::y::TypeY;

functional-tests/error-test-cases/cross-wire/lib/c.simf

@@ -0,0 +1,2 @@
+use lib::y::TypeY;
+use lib::x::TypeX;

functional-tests/error-test-cases/cross-wire/lib/x.simf

@@ -0,0 +1 @@
+pub type TypeX = u32;

functional-tests/error-test-cases/cross-wire/lib/y.simf

@@ -0,0 +1 @@
+pub type TypeY = u64;

functional-tests/error-test-cases/cross-wire/main.simf

@@ -0,0 +1,4 @@
+use lib::b::TypeX;
+use lib::c::TypeY;
+
+fn main() {}

functional-tests/error-test-cases/cyclic-dependency/lib/module_a.simf

@@ -0,0 +1,2 @@
+pub use lib::module_b::TypeB;
+pub type TypeA = u32;

functional-tests/error-test-cases/cyclic-dependency/lib/module_b.simf

@@ -0,0 +1,2 @@
+pub use lib::module_a::TypeA;
+pub type TypeB = u32;

functional-tests/error-test-cases/cyclic-dependency/main.simf

@@ -0,0 +1,3 @@
+use lib::module_a::TypeA; 
+
+fn main() {}

functional-tests/error-test-cases/file-not-found/main.simf

@@ -0,0 +1,5 @@
+use lib::module::AssetId;
+
+fn main() {
+    let my_asset: AssetId = 5; 
+}

functional-tests/error-test-cases/global/lib/module.simf

@@ -0,0 +1,2 @@
+pub type AssetId = u32;
+pub fn get_id() -> AssetId { 1 }

functional-tests/error-test-cases/global/main.simf

@@ -0,0 +1,5 @@
+use lib::module::*;
+
+fn main() {
+    let my_asset: AssetId = 5; 
+}

functional-tests/error-test-cases/lib-not-found/main.simf

@@ -0,0 +1,5 @@
+use lib::module::AssetId;
+
+fn main() {
+    let my_asset: AssetId = 5; 
+}

functional-tests/error-test-cases/name-collision/lib/groups.simf

@@ -0,0 +1,3 @@
+pub fn add(a: u32, b: u32) -> (bool, u32) {
+    jet::add_32(a, b)
+}

functional-tests/error-test-cases/name-collision/lib/math.simf

@@ -0,0 +1,4 @@
+pub fn add(a: u32, b: u32) -> (bool, u32) {
+    let (_, c): (bool, u32) = jet::add_32(a, b);
+    jet::add_32(c, 1)
+}

functional-tests/error-test-cases/name-collision/main.simf

@@ -0,0 +1,9 @@
+use lib::groups::add;
+use lib::math::add;
+
+fn main() {
+    let x: u32 = 5;
+    let y: u32 = 10;
+    let (_, result): (bool, u32) = add(x, y);
+    assert!(jet::eq_32(result, 16));
+}

functional-tests/error-test-cases/private-visibility/lib/hidden.simf

@@ -0,0 +1 @@
+type SecretType = u32; pub fn ok() {}

functional-tests/error-test-cases/private-visibility/main.simf

@@ -0,0 +1,3 @@
+use lib::hidden::SecretType;
+
+fn main() {}

functional-tests/valid-test-cases/deep-reexport-chain/lib/level1.simf

@@ -0,0 +1,2 @@
+pub use lib::level2::CoreSmth;
+pub use lib::level2::core_val;

functional-tests/valid-test-cases/deep-reexport-chain/lib/level2.simf

@@ -0,0 +1,2 @@
+pub use lib::level3::CoreSmth;
+pub use lib::level3::core_val;

functional-tests/valid-test-cases/deep-reexport-chain/lib/level3.simf

@@ -0,0 +1,2 @@
+pub type CoreSmth = u32;
+pub fn core_val() -> CoreSmth { 42 }

functional-tests/valid-test-cases/deep-reexport-chain/main.simf

@@ -0,0 +1,7 @@
+use lib::level1::CoreSmth;
+use lib::level1::core_val;
+
+fn main() {
+    let val: CoreSmth = core_val();
+    assert!(jet::eq_32(val, 42));
+}

functional-tests/valid-test-cases/diamond-dependency-resolution/lib/base.simf

@@ -0,0 +1 @@
+pub type BaseType = u32;

functional-tests/valid-test-cases/diamond-dependency-resolution/lib/left.simf

@@ -0,0 +1,2 @@
+pub use lib::base::BaseType;
+pub fn get_left() -> BaseType { 1 }

functional-tests/valid-test-cases/diamond-dependency-resolution/lib/right.simf

@@ -0,0 +1,2 @@
+pub use lib::base::BaseType;
+pub fn get_right() -> BaseType { 2 }

functional-tests/valid-test-cases/diamond-dependency-resolution/main.simf

@@ -0,0 +1,9 @@
+use lib::left::get_left;
+use lib::right::get_right;
+
+fn main() {
+    let a: BaseType = get_left();
+    let b: BaseType = get_right();
+    let (_, c): (bool, BaseType) = jet::add_32(a, b);
+    assert!(jet::eq_32(c, 3));
+}

functional-tests/valid-test-cases/interleaved-waterfall/auth/verify.simf

@@ -0,0 +1,6 @@
+use types::def::UserId;
+use db::store::get_record;
+
+pub fn is_valid(id: UserId) -> UserId { 
+    get_record(id)
+}

functional-tests/valid-test-cases/interleaved-waterfall/db/store.simf

@@ -0,0 +1,2 @@
+use types::def::UserId;
+pub fn get_record(id: UserId) -> UserId { id }

functional-tests/valid-test-cases/interleaved-waterfall/main.simf

@@ -0,0 +1,5 @@
+use orch::handler::run_system;
+
+fn main() {
+    assert!(jet::eq_32(run_system(5), 5));
+}

functional-tests/valid-test-cases/interleaved-waterfall/orch/handler.simf

@@ -0,0 +1,8 @@
+use auth::verify::is_valid;
+use db::store::get_record;
+use types::def::UserId;
+
+pub fn run_system(id: UserId) -> UserId {
+    let checked: UserId = is_valid(id);
+    get_record(checked)
+}

functional-tests/valid-test-cases/interleaved-waterfall/types/def.simf

@@ -0,0 +1 @@
+pub type UserId = u32;

functional-tests/valid-test-cases/keyword-as-lib/jet/fn/let.simf

@@ -0,0 +1,3 @@
+pub fn get_some_value() -> u64 {
+    1
+}

functional-tests/valid-test-cases/keyword-as-lib/main.simf

@@ -0,0 +1,3 @@
+use r#jet::r#fn::r#let;
+
+pub fn main() {}

functional-tests/valid-test-cases/leaky-signature/lib/internal.simf

@@ -0,0 +1,5 @@
+type SecretKey = u64;
+
+pub fn unlock(key: SecretKey) -> u64 {
+    jet::max_64(key, 0)
+}

functional-tests/valid-test-cases/leaky-signature/main.simf

@@ -0,0 +1,4 @@
+use lib::internal::unlock;
+
+fn main() {
+}

functional-tests/valid-test-cases/module-simple/lib/module.simf

@@ -0,0 +1 @@
+pub fn add() {}

functional-tests/valid-test-cases/module-simple/main.simf

@@ -0,0 +1,2 @@
+use lib::module::add;
+fn main() {}

functional-tests/valid-test-cases/multi-lib-facade/api/api.simf

@@ -0,0 +1,3 @@
+pub use crypto::crypto::mock_hash;
+pub use math::math::MathInt;
+pub use math::math::add_two;

functional-tests/valid-test-cases/multi-lib-facade/crypto/crypto.simf

@@ -0,0 +1,5 @@
+use math::math::MathInt;
+
+pub fn mock_hash(x: MathInt) -> (bool, MathInt) {
+    jet::add_32(x, 5)
+}

functional-tests/valid-test-cases/multi-lib-facade/main.simf

@@ -0,0 +1,8 @@
+use api::api::{add_two, mock_hash, MathInt};
+
+fn main() {
+    let val: MathInt = 10;
+    let (_, step1): (bool, MathInt) = add_two(val);
+    let (_, step2): (bool, MathInt) = mock_hash(step1);
+    assert!(jet::eq_32(step2, 17));
+}

functional-tests/valid-test-cases/multi-lib-facade/math/math.simf

@@ -0,0 +1,4 @@
+pub type MathInt = u32;
+pub fn add_two(x: MathInt) -> (bool, MathInt) { 
+    jet::add_32(x, 2) 
+}

functional-tests/valid-test-cases/reexport-diamond/lib/core.simf

@@ -0,0 +1,2 @@
+pub type Coin = u64;
+pub fn mint(val: u64) -> Coin { val }

functional-tests/valid-test-cases/reexport-diamond/lib/route_a.simf

@@ -0,0 +1,2 @@
+pub use lib::core::Coin;
+pub use lib::core::mint;

functional-tests/valid-test-cases/reexport-diamond/lib/route_b.simf

@@ -0,0 +1,5 @@
+pub use lib::core::Coin;
+
+pub fn burn(c: Coin) -> (bool, Coin) {
+    jet::subtract_64(c, 1)
+}

functional-tests/valid-test-cases/reexport-diamond/main.simf

@@ -0,0 +1,9 @@
+use lib::route_a::Coin;
+use lib::route_a::mint;
+use lib::route_b::burn;
+
+fn main() {
+    let my_coin: Coin = mint(10);
+    let (_, remaining): (bool, Coin) = burn(my_coin);
+    assert!(jet::eq_64(remaining, 9));
+}