AleoHQ/leo
1
1
Fork 0
mirror of https://github.com/AleoHQ/leo.git synced 2024-12-26 11:06:00 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:AleoHQ/leo into expression-breakout

Browse Source
This commit is contained in:
collin 2020-12-16 13:46:43 -05:00
commit 1dbd72c453
97 changed files with 1380 additions and 1249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

344
Cargo.lock generated
View File

@ -79,9 +79,9 @@ checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
[[package]]
name = "backtrace"
version = "0.3.54"
version = "0.3.55"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2baad346b2d4e94a24347adeee9c7a93f412ee94b9cc26e5b59dea23848e9f28"
checksum = "ef5140344c85b01f9bbb4d4b7288a8aa4b3287ccef913a14bcc78a1063623598"
dependencies = [
"addr2line",
"cfg-if 1.0.0",
@ -107,12 +107,6 @@ dependencies = [
"safemem",
]
[[package]]
name = "base64"
version = "0.12.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff"
[[package]]
name = "base64"
version = "0.13.0"
@ -296,9 +290,9 @@ dependencies = [
[[package]]
name = "cc"
version = "1.0.62"
version = "1.0.66"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f1770ced377336a88a67c473594ccc14eca6f4559217c34f64aac8f83d641b40"
checksum = "4c0496836a84f8d0495758516b8621a622beb77c0fed418570e50764093ced48"
dependencies = [
"jobserver",
]
@ -373,15 +367,6 @@ dependencies = [
"vec_map",
]
[[package]]
name = "cloudabi"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4344512281c643ae7638bbabc3af17a11307803ec8f0fcad9fae512a8bf36467"
dependencies = [
"bitflags",
]
[[package]]
name = "colored"
version = "2.0.0"
@ -409,21 +394,11 @@ dependencies = [
"winapi-util",
]
[[package]]
name = "console_error_panic_hook"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8d976903543e0c48546a91908f21588a680a8c8f984df9a5d69feccb2b2a211"
dependencies = [
"cfg-if 0.1.10",
"wasm-bindgen",
]
[[package]]
name = "const_fn"
version = "0.4.3"
version = "0.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c478836e029dcef17fb47c89023448c64f781a046e0300e257ad8225ae59afab"
checksum = "cd51eab21ab4fd6a3bf889e2d0958c0a6e3a61ad04260325e919e652a2a62826"
[[package]]
name = "constant_time_eq"
@ -505,7 +480,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dca26ee1f8d361640700bde38b2c37d8c22b3ce2d360e1fc1c74ea4b0aa7d775"
dependencies = [
"cfg-if 1.0.0",
"crossbeam-utils 0.8.0",
"crossbeam-utils",
]
[[package]]
@ -516,18 +491,18 @@ checksum = "94af6efb46fef72616855b036a624cf27ba656ffc9be1b9a3c931cfc7749a9a9"
dependencies = [
"cfg-if 1.0.0",
"crossbeam-epoch",
"crossbeam-utils 0.8.0",
"crossbeam-utils",
]
[[package]]
name = "crossbeam-epoch"
version = "0.9.0"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec0f606a85340376eef0d6d8fec399e6d4a544d648386c6645eb6d0653b27d9f"
checksum = "a1aaa739f95311c2c7887a76863f500026092fb1dce0161dab577e559ef3569d"
dependencies = [
"cfg-if 1.0.0",
"const_fn",
"crossbeam-utils 0.8.0",
"crossbeam-utils",
"lazy_static",
"memoffset",
"scopeguard",
@ -535,24 +510,12 @@ dependencies = [
[[package]]
name = "crossbeam-utils"
version = "0.7.2"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8"
dependencies = [
"autocfg",
"cfg-if 0.1.10",
"lazy_static",
]
[[package]]
name = "crossbeam-utils"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec91540d98355f690a86367e566ecad2e9e579f230230eb7c21398372be73ea5"
checksum = "02d96d1e189ef58269ebe5b97953da3274d83a93af647c2ddd6f9dab28cedb8d"
dependencies = [
"autocfg",
"cfg-if 1.0.0",
"const_fn",
"lazy_static",
]
@ -568,9 +531,9 @@ dependencies = [
[[package]]
name = "csv"
version = "1.1.4"
version = "1.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fc4666154fd004af3fd6f1da2e81a96fd5a81927fe8ddb6ecc79e2aa6e138b54"
checksum = "f9d58633299b24b515ac72a3f869f8b91306a3cec616a602843a383acd6f9e97"
dependencies = [
"bstr",
"csv-core",
@ -605,9 +568,9 @@ dependencies = [
[[package]]
name = "curl-sys"
version = "0.4.38+curl-7.73.0"
version = "0.4.39+curl-7.74.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "498ecfb4f59997fd40023d62a9f1e506e768b2baeb59a1d311eb9751cdcd7e3f"
checksum = "07a8ce861e7b68a0b394e814d7ee9f1b2750ff8bd10372c6ad3bacc10e86f874"
dependencies = [
"cc",
"libc",
@ -626,7 +589,7 @@ checksum = "cb582b60359da160a9477ee80f15c8d784c477e69c217ef2cdd4169c24ea380f"
dependencies = [
"proc-macro2 1.0.24",
"quote 1.0.7",
"syn 1.0.48",
"syn 1.0.54",
]
[[package]]
@ -748,7 +711,7 @@ checksum = "aa4da3c766cd7a0db8242e326e9e4e081edd567072893ed320008189715366a4"
dependencies = [
"proc-macro2 1.0.24",
"quote 1.0.7",
"syn 1.0.48",
"syn 1.0.54",
"synstructure",
]
@ -916,7 +879,7 @@ dependencies = [
"futures-io",
"futures-task",
"memchr",
"pin-project 1.0.1",
"pin-project 1.0.2",
"pin-utils",
"slab",
]
@ -1096,7 +1059,7 @@ dependencies = [
"httparse",
"httpdate",
"itoa",
"pin-project 1.0.1",
"pin-project 1.0.2",
"socket2",
"tokio",
"tower-service",
@ -1147,12 +1110,13 @@ dependencies = [
[[package]]
name = "indexmap"
version = "1.6.0"
version = "1.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "55e2e4c765aa53a0424761bf9f41aa7a6ac1efa87238f59560640e27fca028f2"
checksum = "4fb1fa934250de4de8aef298d81c729a7d33d8c239daa3a7575e6b92bfc7313b"
dependencies = [
"autocfg",
"hashbrown",
"serde",
]
[[package]]
@ -1189,9 +1153,9 @@ dependencies = [
[[package]]
name = "instant"
version = "0.1.8"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cb1fc4429a33e1f80d41dc9fea4d108a88bec1de8053878898ae448a0b52f613"
checksum = "61124eeebbd69b8190558df225adf7e4caafce0d743919e5d6b19652314ec5ec"
dependencies = [
"cfg-if 1.0.0",
]
@ -1246,9 +1210,9 @@ dependencies = [
[[package]]
name = "js-sys"
version = "0.3.45"
version = "0.3.46"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca059e81d9486668f12d455a4ea6daa600bd408134cd17e3d3fb5a32d1f016f8"
checksum = "cf3d7383929f7c9c7c2d0fa596f325832df98c3704f2c60553080f7127a58175"
dependencies = [
"wasm-bindgen",
]
@ -1296,9 +1260,10 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
[[package]]
name = "leo-ast"
version = "1.0.6"
version = "1.0.7"
dependencies = [
"criterion",
"indexmap",
"leo-grammar",
"leo-input",
"pest",
@ -1310,10 +1275,11 @@ dependencies = [
[[package]]
name = "leo-compiler"
version = "1.0.6"
version = "1.0.7"
dependencies = [
"bincode",
"hex",
"indexmap",
"leo-ast",
"leo-core",
"leo-gadgets",
@ -1345,7 +1311,7 @@ dependencies = [
[[package]]
name = "leo-core"
version = "1.0.6"
version = "1.0.7"
dependencies = [
"leo-ast",
"leo-gadgets",
@ -1361,7 +1327,7 @@ dependencies = [
[[package]]
name = "leo-gadgets"
version = "1.0.6"
version = "1.0.7"
dependencies = [
"criterion",
"rand",
@ -1374,7 +1340,7 @@ dependencies = [
[[package]]
name = "leo-grammar"
version = "1.0.6"
version = "1.0.7"
dependencies = [
"criterion",
"from-pest",
@ -1390,8 +1356,9 @@ dependencies = [
[[package]]
name = "leo-imports"
version = "1.0.6"
version = "1.0.7"
dependencies = [
"indexmap",
"leo-ast",
"leo-grammar",
"thiserror",
@ -1400,7 +1367,7 @@ dependencies = [
[[package]]
name = "leo-input"
version = "1.0.6"
version = "1.0.7"
dependencies = [
"from-pest",
"pest",
@ -1417,7 +1384,7 @@ dependencies = [
[[package]]
name = "leo-lang"
version = "1.0.6"
version = "1.0.7"
dependencies = [
"clap",
"colored",
@ -1437,7 +1404,7 @@ dependencies = [
"notify",
"num-bigint",
"rand",
"rand_core",
"rand_core 0.6.0",
"reqwest",
"rusty-hook",
"self_update",
@ -1458,11 +1425,11 @@ dependencies = [
[[package]]
name = "leo-linter"
version = "1.0.6"
version = "1.0.7"
[[package]]
name = "leo-package"
version = "1.0.6"
version = "1.0.7"
dependencies = [
"lazy_static",
"serde",
@ -1476,8 +1443,9 @@ dependencies = [
[[package]]
name = "leo-state"
version = "1.0.6"
version = "1.0.7"
dependencies = [
"indexmap",
"leo-ast",
"leo-input",
"rand",
@ -1495,8 +1463,9 @@ dependencies = [
[[package]]
name = "leo-symbol-table"
version = "1.0.6"
version = "1.0.7"
dependencies = [
"indexmap",
"leo-ast",
"leo-core",
"leo-grammar",
@ -1507,8 +1476,9 @@ dependencies = [
[[package]]
name = "leo-type-inference"
version = "1.0.6"
version = "1.0.7"
dependencies = [
"indexmap",
"leo-ast",
"leo-grammar",
"leo-imports",
@ -1520,9 +1490,9 @@ dependencies = [
[[package]]
name = "libc"
version = "0.2.80"
version = "0.2.81"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4d58d1b70b004888f764dfbf6a26a3b0342a1632d33968e4a179d8011c760614"
checksum = "1482821306169ec4d07f6aca392a4681f66c75c9918aa49641a2595db64053cb"
[[package]]
name = "libloading"
@ -1560,9 +1530,9 @@ dependencies = [
[[package]]
name = "lock_api"
version = "0.4.1"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "28247cc5a5be2f05fbcd76dd0cf2c7d3b5400cb978a28042abcd4fa0b3f8261c"
checksum = "dd96ffd135b2fd7b973ac026d28085defbe8983df057ced3eb4f2130b0831312"
dependencies = [
"scopeguard",
]
@ -1618,9 +1588,9 @@ checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"
[[package]]
name = "memoffset"
version = "0.5.6"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "043175f069eda7b85febe4a74abbaeff828d9f8b448515d3151a14a3542811aa"
checksum = "157b4208e3059a8f9e78d559edc658e13df41410cb3ae03979c83130067fdd87"
dependencies = [
"autocfg",
]
@ -1662,9 +1632,9 @@ dependencies = [
[[package]]
name = "mio"
version = "0.6.22"
version = "0.6.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fce347092656428bc8eaf6201042cb551b8d67855af7374542a92a0fbfcac430"
checksum = "4afd66f5b91bf2a3bc13fad0e21caedac168ca4c707504e75585648ae80e4cc4"
dependencies = [
"cfg-if 0.1.10",
"fuchsia-zircon",
@ -1693,9 +1663,9 @@ dependencies = [
[[package]]
name = "miow"
version = "0.2.1"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919"
checksum = "ebd808424166322d4a38da87083bfddd3ac4c131334ed55856112eb06d46944d"
dependencies = [
"kernel32-sys",
"net2",
@ -1723,9 +1693,9 @@ dependencies = [
[[package]]
name = "net2"
version = "0.2.35"
version = "0.2.37"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ebc3ec692ed7c9a255596c67808dee269f64655d8baf7b4f0638e51ba1d6853"
checksum = "391630d12b68002ae1e25e8f974306474966550ad82dac6886fb8910c19568ae"
dependencies = [
"cfg-if 0.1.10",
"libc",
@ -1820,15 +1790,15 @@ checksum = "8d3b63360ec3cb337817c2dbd47ab4a0f170d285d8e5a2064600f3def1402397"
[[package]]
name = "once_cell"
version = "1.5.1"
version = "1.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f53cef67919d7d247eb9a2f128ca9e522789967ef1eb4ccd8c71a95a8aedf596"
checksum = "13bd41f508810a131401606d54ac32a467c97172d74ba7662562ebba5ad07fa0"
[[package]]
name = "oorandom"
version = "11.1.2"
version = "11.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a170cebd8021a008ea92e4db85a72f80b35df514ec664b296fdcbb654eac0b2c"
checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
[[package]]
name = "opaque-debug"
@ -1844,12 +1814,12 @@ checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
[[package]]
name = "openssl"
version = "0.10.30"
version = "0.10.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d575eff3665419f9b83678ff2815858ad9d11567e082f5ac1814baba4e2bcb4"
checksum = "8d008f51b1acffa0d3450a68606e6a51c123012edaacb0f4e1426bd978869187"
dependencies = [
"bitflags",
"cfg-if 0.1.10",
"cfg-if 1.0.0",
"foreign-types",
"lazy_static",
"libc",
@ -1864,9 +1834,9 @@ checksum = "77af24da69f9d9341038eba93a073b1fdaaa1b788221b00a69bce9e762cb32de"
[[package]]
name = "openssl-sys"
version = "0.9.58"
version = "0.9.59"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a842db4709b604f0fe5d1170ae3565899be2ad3d9cbc72dedc789ac0511f78de"
checksum = "de52d8eabd217311538a39bba130d7dea1f1e118010fee7a033d966845e7d5fe"
dependencies = [
"autocfg",
"cc",
@ -1877,9 +1847,9 @@ dependencies = [
[[package]]
name = "parking_lot"
version = "0.11.0"
version = "0.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a4893845fa2ca272e647da5d0e46660a314ead9c2fdd9a883aabc32e481a8733"
checksum = "6d7744ac029df22dca6284efe4e898991d28e3085c706c972bcd7da4a27a15eb"
dependencies = [
"instant",
"lock_api",
@ -1888,12 +1858,11 @@ dependencies = [
[[package]]
name = "parking_lot_core"
version = "0.8.0"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c361aa727dd08437f2f1447be8b59a33b0edd15e0fcee698f935613d9efbca9b"
checksum = "d7c6d9b8427445284a09c55be860a15855ab580a417ccad9da88f5a06787ced0"
dependencies = [
"cfg-if 0.1.10",
"cloudabi",
"cfg-if 1.0.0",
"instant",
"libc",
"redox_syscall",
@ -1961,7 +1930,7 @@ dependencies = [
"pest_meta",
"proc-macro2 1.0.24",
"quote 1.0.7",
"syn 1.0.48",
"syn 1.0.54",
]
[[package]]
@ -1986,11 +1955,11 @@ dependencies = [
[[package]]
name = "pin-project"
version = "1.0.1"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee41d838744f60d959d7074e3afb6b35c7456d0f61cad38a24e35e6553f73841"
checksum = "9ccc2237c2c489783abd8c4c80e5450fc0e98644555b1364da68cc29aa151ca7"
dependencies = [
"pin-project-internal 1.0.1",
"pin-project-internal 1.0.2",
]
[[package]]
@ -2001,18 +1970,18 @@ checksum = "65ad2ae56b6abe3a1ee25f15ee605bacadb9a764edaba9c2bf4103800d4a1895"
dependencies = [
"proc-macro2 1.0.24",
"quote 1.0.7",
"syn 1.0.48",
"syn 1.0.54",
]
[[package]]
name = "pin-project-internal"
version = "1.0.1"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "81a4ffa594b66bff340084d4081df649a7dc049ac8d7fc458d8e628bfbbb2f86"
checksum = "f8e8d2bf0b23038a4424865103a4df472855692821aab4e4f5c3312d461d9e5f"
dependencies = [
"proc-macro2 1.0.24",
"quote 1.0.7",
"syn 1.0.48",
"syn 1.0.54",
]
[[package]]
@ -2117,7 +2086,7 @@ dependencies = [
"getrandom",
"libc",
"rand_chacha",
"rand_core",
"rand_core 0.5.1",
"rand_hc",
]
@ -2128,7 +2097,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
dependencies = [
"ppv-lite86",
"rand_core",
"rand_core 0.5.1",
]
[[package]]
@ -2140,13 +2109,19 @@ dependencies = [
"getrandom",
]
[[package]]
name = "rand_core"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a8b34ba8cfb21243bd8df91854c830ff0d785fff2e82ebd4434c2644cb9ada18"
[[package]]
name = "rand_hc"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
dependencies = [
"rand_core",
"rand_core 0.5.1",
]
[[package]]
@ -2155,7 +2130,7 @@ version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77d416b86801d23dde1aa643023b775c3a462efc0ed96443add11546cdf1dca8"
dependencies = [
"rand_core",
"rand_core 0.5.1",
]
[[package]]
@ -2178,7 +2153,7 @@ checksum = "9ab346ac5921dc62ffa9f89b7a773907511cdfa5490c572ae9be1be33e8afa4a"
dependencies = [
"crossbeam-channel",
"crossbeam-deque",
"crossbeam-utils 0.8.0",
"crossbeam-utils",
"lazy_static",
"num_cpus",
]
@ -2239,9 +2214,9 @@ dependencies = [
[[package]]
name = "reqwest"
version = "0.10.9"
version = "0.10.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fb15d6255c792356a0f578d8a645c677904dc02e862bebe2ecc18e0c01b9a0ce"
checksum = "0718f81a8e14c4dbb3b34cf23dc6aaf9ab8a0dfec160c534b3dbca1aaa21f47c"
dependencies = [
"base64 0.13.0",
"bytes 0.5.6",
@ -2269,7 +2244,6 @@ dependencies = [
"url",
"wasm-bindgen",
"wasm-bindgen-futures",
"wasm-bindgen-test",
"web-sys",
"winreg",
]
@ -2286,14 +2260,14 @@ dependencies = [
[[package]]
name = "rust-argon2"
version = "0.8.2"
version = "0.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9dab61250775933275e84053ac235621dfb739556d5c54a2f2e9313b7cf43a19"
checksum = "4b18820d944b33caa75a71378964ac46f58517c92b6ae5f762636247c09e78fb"
dependencies = [
"base64 0.12.3",
"base64 0.13.0",
"blake2b_simd",
"constant_time_eq",
"crossbeam-utils 0.7.2",
"crossbeam-utils",
]
[[package]]
@ -2448,9 +2422,9 @@ dependencies = [
[[package]]
name = "serde"
version = "1.0.117"
version = "1.0.118"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b88fa983de7720629c9387e9f517353ed404164b1e482c970a90c1a4aaf7dc1a"
checksum = "06c64263859d87aa2eb554587e2d23183398d617427327cf2b3d0ed8c69e4800"
dependencies = [
"serde_derive",
]
@ -2467,13 +2441,13 @@ dependencies = [
[[package]]
name = "serde_derive"
version = "1.0.117"
version = "1.0.118"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cbd1ae72adb44aab48f325a02444a5fc079349a8d804c1fc922aed3f7454c74e"
checksum = "c84d3526699cd55261af4b941e4e725444df67aa4f9e6a3564f18030d12672df"
dependencies = [
"proc-macro2 1.0.24",
"quote 1.0.7",
"syn 1.0.48",
"syn 1.0.54",
]
[[package]]
@ -2557,9 +2531,9 @@ checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
[[package]]
name = "smallvec"
version = "1.4.2"
version = "1.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fbee7696b84bbf3d89a1c2eccff0850e3047ed46bfcd2e92c29a2d074d57e252"
checksum = "ae524f056d7d770e174287294f562e95044c68e88dec909a00d2094805db9d75"
[[package]]
name = "snarkos-algorithms"
@ -2606,7 +2580,7 @@ checksum = "a8f6ce35f9f73c13e5381c6938747935ca105e22717998489c3e5ddb8c13120d"
dependencies = [
"proc-macro2 1.0.24",
"quote 1.0.7",
"syn 1.0.48",
"syn 1.0.54",
]
[[package]]
@ -2757,11 +2731,11 @@ dependencies = [
[[package]]
name = "socket2"
version = "0.3.16"
version = "0.3.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7fd8b795c389288baa5f355489c65e71fd48a02104600d15c4cfbc561e9e429d"
checksum = "2c29947abdee2a218277abeca306f25789c938e500ea5a9d4b12a5a504466902"
dependencies = [
"cfg-if 0.1.10",
"cfg-if 1.0.0",
"libc",
"redox_syscall",
"winapi 0.3.9",
@ -2792,9 +2766,9 @@ dependencies = [
[[package]]
name = "syn"
version = "1.0.48"
version = "1.0.54"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc371affeffc477f42a221a1e4297aedcea33d47d19b61455588bd9d8f6b19ac"
checksum = "9a2af957a63d6bd42255c359c93d9bfdb97076bd3b820897ce55ffbfbf107f44"
dependencies = [
"proc-macro2 1.0.24",
"quote 1.0.7",
@ -2809,7 +2783,7 @@ checksum = "b834f2d66f734cb897113e34aaff2f1ab4719ca946f9a7358dba8f8064148701"
dependencies = [
"proc-macro2 1.0.24",
"quote 1.0.7",
"syn 1.0.48",
"syn 1.0.54",
"unicode-xid 0.2.1",
]
@ -2829,18 +2803,18 @@ dependencies = [
[[package]]
name = "termcolor"
version = "1.1.0"
version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bb6bfa289a4d7c5766392812c0a1f4c1ba45afa1ad47803c11e1f407d846d75f"
checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
dependencies = [
"winapi-util",
]
[[package]]
name = "terminal_size"
version = "0.1.13"
version = "0.1.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a14cd9f8c72704232f0bfc8455c0e861f0ad4eb60cc9ec8a170e231414c1e13"
checksum = "4bd2d183bd3fac5f5fe38ddbeb4dc9aec4a39a9d7d59e7491d900302da01cbe1"
dependencies = [
"libc",
"winapi 0.3.9",
@ -2872,7 +2846,7 @@ checksum = "9ba20f23e85b10754cd195504aebf6a27e2e6cbe28c17778a0c930724628dd56"
dependencies = [
"proc-macro2 1.0.24",
"quote 1.0.7",
"syn 1.0.48",
"syn 1.0.54",
]
[[package]]
@ -2907,9 +2881,9 @@ dependencies = [
[[package]]
name = "tinyvec"
version = "1.0.1"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b78a366903f506d2ad52ca8dc552102ffdd3e937ba8a227f024dc1d1eae28575"
checksum = "ccf8dbc19eb42fba10e8feaaec282fb50e2c14b2726d6301dbfeed0f73306a6f"
dependencies = [
"tinyvec_macros",
]
@ -2922,9 +2896,9 @@ checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
[[package]]
name = "tokio"
version = "0.2.22"
version = "0.2.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d34ca54d84bf2b5b4d7d31e901a8464f7b60ac145a284fba25ceb801f2ddccd"
checksum = "099837d3464c16a808060bb3f02263b412f6fafcb5d01c533d309985fbeebe48"
dependencies = [
"bytes 0.5.6",
"fnv",
@ -2998,7 +2972,7 @@ checksum = "80e0ccfc3378da0cce270c946b676a376943f5cd16aeba64568e7939806f4ada"
dependencies = [
"proc-macro2 1.0.24",
"quote 1.0.7",
"syn 1.0.48",
"syn 1.0.54",
]
[[package]]
@ -3101,9 +3075,9 @@ dependencies = [
[[package]]
name = "unicode-normalization"
version = "0.1.14"
version = "0.1.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b7f98e67a4d84f730d343392f9bfff7d21e3fca562b9cb7a43b768350beeddc6"
checksum = "a13e63ab62dbe32aeee58d1c5408d35c36c392bba5d9d3142287219721afe606"
dependencies = [
"tinyvec",
]
@ -3140,9 +3114,9 @@ dependencies = [
[[package]]
name = "vcpkg"
version = "0.2.10"
version = "0.2.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6454029bf181f092ad1b853286f23e2c507d8e8194d01d92da4a55c274a5508c"
checksum = "b00bca6106a5e23f3eee943593759b7fcddb00554332e856d990c893966879fb"
[[package]]
name = "vec_map"
@ -3197,11 +3171,11 @@ checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
[[package]]
name = "wasm-bindgen"
version = "0.2.68"
version = "0.2.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ac64ead5ea5f05873d7c12b545865ca2b8d28adfc50a49b84770a3a97265d42"
checksum = "3cd364751395ca0f68cafb17666eee36b63077fb5ecd972bbcd74c90c4bf736e"
dependencies = [
"cfg-if 0.1.10",
"cfg-if 1.0.0",
"serde",
"serde_json",
"wasm-bindgen-macro",
@ -3209,26 +3183,26 @@ dependencies = [
[[package]]
name = "wasm-bindgen-backend"
version = "0.2.68"
version = "0.2.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f22b422e2a757c35a73774860af8e112bff612ce6cb604224e8e47641a9e4f68"
checksum = "1114f89ab1f4106e5b55e688b828c0ab0ea593a1ea7c094b141b14cbaaec2d62"
dependencies = [
"bumpalo",
"lazy_static",
"log",
"proc-macro2 1.0.24",
"quote 1.0.7",
"syn 1.0.48",
"syn 1.0.54",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-futures"
version = "0.4.18"
version = "0.4.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b7866cab0aa01de1edf8b5d7936938a7e397ee50ce24119aef3e1eaa3b6171da"
checksum = "1fe9756085a84584ee9457a002b7cdfe0bfff169f45d2591d8be1345a6780e35"
dependencies = [
"cfg-if 0.1.10",
"cfg-if 1.0.0",
"js-sys",
"wasm-bindgen",
"web-sys",
@ -3236,9 +3210,9 @@ dependencies = [
[[package]]
name = "wasm-bindgen-macro"
version = "0.2.68"
version = "0.2.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6b13312a745c08c469f0b292dd2fcd6411dba5f7160f593da6ef69b64e407038"
checksum = "7a6ac8995ead1f084a8dea1e65f194d0973800c7f571f6edd70adf06ecf77084"
dependencies = [
"quote 1.0.7",
"wasm-bindgen-macro-support",
@ -3246,52 +3220,28 @@ dependencies = [
[[package]]
name = "wasm-bindgen-macro-support"
version = "0.2.68"
version = "0.2.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f249f06ef7ee334cc3b8ff031bfc11ec99d00f34d86da7498396dc1e3b1498fe"
checksum = "b5a48c72f299d80557c7c62e37e7225369ecc0c963964059509fbafe917c7549"
dependencies = [
"proc-macro2 1.0.24",
"quote 1.0.7",
"syn 1.0.48",
"syn 1.0.54",
"wasm-bindgen-backend",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
version = "0.2.68"
version = "0.2.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d649a3145108d7d3fbcde896a468d1bd636791823c9921135218ad89be08307"
[[package]]
name = "wasm-bindgen-test"
version = "0.3.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34d1cdc8b98a557f24733d50a1199c4b0635e465eecba9c45b214544da197f64"
dependencies = [
"console_error_panic_hook",
"js-sys",
"scoped-tls",
"wasm-bindgen",
"wasm-bindgen-futures",
"wasm-bindgen-test-macro",
]
[[package]]
name = "wasm-bindgen-test-macro"
version = "0.3.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e8fb9c67be7439ee8ab1b7db502a49c05e51e2835b66796c705134d9b8e1a585"
dependencies = [
"proc-macro2 1.0.24",
"quote 1.0.7",
]
checksum = "7e7811dd7f9398f14cc76efd356f98f03aa30419dea46aa810d71e819fc97158"
[[package]]
name = "web-sys"
version = "0.3.45"
version = "0.3.46"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4bf6ef87ad7ae8008e15a355ce696bed26012b7caa21605188cfd8214ab51e2d"
checksum = "222b1ef9334f92a21d3fb53dc3fd80f30836959a90f9274a626d7e06315ba3c3"
dependencies = [
"js-sys",
"wasm-bindgen",
@ -3370,9 +3320,9 @@ dependencies = [
[[package]]
name = "zip"
version = "0.5.8"
version = "0.5.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "543adf038106b64cfca4711c82c917d785e3540e04f7996554488f988ec43124"
checksum = "cc2896475a242c41366941faa27264df2cb935185a92e059a004d0048feb2ac5"
dependencies = [
"byteorder",
"bzip2",

20
Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "leo-lang"
version = "1.0.6"
version = "1.0.7"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "The Leo programming language"
homepage = "https://aleo.org"
@ -42,31 +42,31 @@ members = [
[dependencies.leo-ast]
path = "./ast"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-compiler]
path = "./compiler"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-gadgets]
path = "./gadgets"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-imports]
path = "./imports"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-input]
path = "./input"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-package]
path = "./package"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-state]
path = "./state"
version = "1.0.6"
version = "1.0.7"
[dependencies.snarkos-algorithms]
version = "1.1.3"
@ -125,10 +125,10 @@ version = "0.3"
version = "0.7"
[dependencies.rand_core]
version = "0.5.1"
version = "0.6.0"
[dependencies.reqwest]
version = "0.10.9"
version = "0.10.10"
features = [ "blocking", "json" ]
[dependencies.self_update]

10
ast/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "leo-ast"
version = "1.0.6"
version = "1.0.7"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "Core AST of the Leo programming language"
homepage = "https://aleo.org"
@ -28,11 +28,11 @@ harness = false
[dependencies.leo-grammar]
path = "../grammar"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-input]
path = "../input"
version = "1.0.6"
version = "1.0.7"
[dependencies.snarkos-errors]
version = "1.1.3"
@ -42,6 +42,10 @@ default-features = false
version = "1.1.3"
default-features = false
[dependencies.indexmap]
version = "1.6.1"
features = [ "serde-1" ]
[dependencies.pest]
version = "2.0"

12
ast/src/annotation.rs
View File

@ -20,14 +20,14 @@ use leo_grammar::{
definitions::{AnnotatedDefinition, Definition},
};
use std::collections::HashMap;
use indexmap::IndexMap;
pub fn load_annotation(
annotated_definition: AnnotatedDefinition,
_imports: &mut Vec<ImportStatement>,
_circuits: &mut HashMap<Identifier, Circuit>,
_functions: &mut HashMap<Identifier, Function>,
tests: &mut HashMap<Identifier, TestFunction>,
_circuits: &mut IndexMap<Identifier, Circuit>,
_functions: &mut IndexMap<Identifier, Function>,
tests: &mut IndexMap<Identifier, TestFunction>,
_expected: &mut Vec<FunctionInput>,
) {
let ast_annotation = annotated_definition.annotation;
@ -45,7 +45,7 @@ pub fn load_annotation(
}
}
pub fn load_annotated_test(test: TestFunction, annotation: Annotation, tests: &mut HashMap<Identifier, TestFunction>) {
pub fn load_annotated_test(test: TestFunction, annotation: Annotation, tests: &mut IndexMap<Identifier, TestFunction>) {
let name = annotation.name;
let ast_arguments = annotation.arguments;
@ -57,7 +57,7 @@ pub fn load_annotated_test(test: TestFunction, annotation: Annotation, tests: &m
pub fn load_annotated_test_context(
mut test: TestFunction,
ast_arguments: AnnotationArguments,
tests: &mut HashMap<Identifier, TestFunction>,
tests: &mut IndexMap<Identifier, TestFunction>,
) {
let arguments = ast_arguments.arguments;

9
ast/src/functions/function.rs
View File

@ -77,13 +77,10 @@ impl Function {
}
///
/// Returns a vector of [&FunctionInput] removing `self` and `mut self` inputs.
/// Returns an iterator of [&FunctionInput] removing `self` and `mut self` inputs.
///
pub fn filter_self_inputs(&self) -> Vec<&FunctionInput> {
self.input
.iter()
.filter(|input| !input.is_self())
.collect::<Vec<&FunctionInput>>()
pub fn filter_self_inputs(&self) -> impl Iterator<Item = &FunctionInput> {
self.input.iter().filter(|input| !input.is_self())
}
fn format(&self, f: &mut fmt::Formatter) -> fmt::Result {

6
ast/src/input/macros.rs
View File

@ -22,7 +22,7 @@ macro_rules! input_section_impl {
#[derive(Clone, PartialEq, Eq, Default)]
pub struct $name {
is_present: bool,
values: HashMap<Parameter, Option<InputValue>>,
values: IndexMap<Parameter, Option<InputValue>>,
}
impl $name {
@ -63,8 +63,8 @@ macro_rules! input_section_impl {
Ok(())
}
/// Returns this section's hashmap of values
pub fn values(&self) -> HashMap<Parameter, Option<InputValue>> {
/// Returns this section's [IndexMap] of values
pub fn values(&self) -> IndexMap<Parameter, Option<InputValue>> {
self.values.clone()
}
}

5
ast/src/input/program_input/main_input.rs
View File

@ -16,11 +16,12 @@
use crate::InputValue;
use leo_input::{definitions::Definition, InputParserError};
use std::collections::HashMap;
use indexmap::IndexMap;
#[derive(Clone, PartialEq, Eq, Default)]
pub struct MainInput {
input: HashMap<String, Option<InputValue>>,
input: IndexMap<String, Option<InputValue>>,
}
#[allow(clippy::len_without_is_empty)]

2
ast/src/input/program_input/registers.rs
View File

@ -17,6 +17,6 @@
use crate::{InputValue, Parameter};
use leo_input::{definitions::Definition, InputParserError};
use std::collections::HashMap;
use indexmap::IndexMap;
input_section_impl!(Registers);

2
ast/src/input/program_state/private_state/record.rs
View File

@ -17,6 +17,6 @@
use crate::{InputValue, Parameter};
use leo_input::{definitions::Definition, InputParserError};
use std::collections::HashMap;
use indexmap::IndexMap;
input_section_impl!(Record);

2
ast/src/input/program_state/private_state/state_leaf.rs
View File

@ -17,6 +17,6 @@
use crate::{InputValue, Parameter};
use leo_input::{definitions::Definition, InputParserError};
use std::collections::HashMap;
use indexmap::IndexMap;
input_section_impl!(StateLeaf);

2
ast/src/input/program_state/public_state/state.rs
View File

@ -17,6 +17,6 @@
use crate::{InputValue, Parameter};
use leo_input::{definitions::Definition, InputParserError};
use std::collections::HashMap;
use indexmap::IndexMap;
input_section_impl!(State);

21
ast/src/program.rs
View File

@ -20,18 +20,17 @@
use crate::{load_annotation, Circuit, Function, FunctionInput, Identifier, ImportStatement, TestFunction};
use leo_grammar::{definitions::Definition, files::File};
use indexmap::IndexMap;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
/// Stores the Leo program abstract syntax tree.
#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct Program {
pub name: String,
pub expected_input: Vec<FunctionInput>,
pub imports: Vec<ImportStatement>,
pub circuits: HashMap<Identifier, Circuit>,
pub functions: HashMap<Identifier, Function>,
pub tests: HashMap<Identifier, TestFunction>,
pub circuits: IndexMap<Identifier, Circuit>,
pub functions: IndexMap<Identifier, Function>,
pub tests: IndexMap<Identifier, TestFunction>,
}
const MAIN_FUNCTION_NAME: &str = "main";
@ -40,9 +39,9 @@ impl<'ast> Program {
//! Logic to convert from an abstract syntax tree (ast) representation to a Leo program.
pub fn from(program_name: &str, program_ast: &File<'ast>) -> Self {
let mut imports = vec![];
let mut circuits = HashMap::new();
let mut functions = HashMap::new();
let mut tests = HashMap::new();
let mut circuits = IndexMap::new();
let mut functions = IndexMap::new();
let mut tests = IndexMap::new();
let mut expected_input = vec![];
program_ast
@ -94,9 +93,9 @@ impl Program {
name,
expected_input: vec![],
imports: vec![],
circuits: HashMap::new(),
functions: HashMap::new(),
tests: HashMap::new(),
circuits: IndexMap::new(),
functions: IndexMap::new(),
tests: IndexMap::new(),
}
}

26
compiler/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "leo-compiler"
version = "1.0.6"
version = "1.0.7"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "Compiler of the Leo programming language"
homepage = "https://aleo.org"
@ -19,43 +19,43 @@ edition = "2018"
[dependencies.leo-ast]
path = "../ast"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-core]
path = "../core"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-gadgets]
path = "../gadgets"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-grammar]
path = "../grammar"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-imports]
path = "../imports"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-input]
path = "../input"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-package]
path = "../package"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-state]
path = "../state"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-symbol-table]
path = "../symbol-table"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-type-inference]
path = "../type-inference"
version = "1.0.6"
version = "1.0.7"
[dependencies.snarkos-curves]
version = "1.1.3"
@ -90,6 +90,10 @@ version = "1.0"
[dependencies.hex]
version = "0.4.2"
[dependencies.indexmap]
version = "1.6.1"
features = [ "serde-1" ]
[dependencies.pest]
version = "2.0"

3
compiler/src/compiler.rs
View File

@ -229,9 +229,6 @@ impl<F: Field + PrimeField, G: GroupType<F>> Compiler<F, G> {
/// Equivalent to parse_and_check_program but uses the given program_string instead of a main
/// file path.
///
/// Used for testing only.
///
#[deprecated(note = "Please use the 'parse_program' method instead.")]
pub fn parse_program_from_string(&mut self, program_string: &str) -> Result<(), CompilerError> {
// Use the given bytes to construct the abstract syntax tree.
let ast = Grammar::new(&self.main_file_path, &program_string).map_err(|mut e| {

18
compiler/src/console/assert.rs
View File

@ -16,7 +16,13 @@
//! Enforces an assert equals statement in a compiled Leo program.
use crate::{errors::ConsoleError, program::ConstrainedProgram, value::ConstrainedValue, GroupType};
use crate::{
errors::ConsoleError,
get_indicator_value,
program::ConstrainedProgram,
value::ConstrainedValue,
GroupType,
};
use leo_ast::{Expression, Span, Type};
use snarkos_models::{
@ -30,7 +36,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
cs: &mut CS,
file_scope: &str,
function_scope: &str,
indicator: Option<Boolean>,
indicator: &Boolean,
expression: Expression,
span: &Span,
) -> Result<(), ConsoleError> {
@ -42,12 +48,8 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// If the indicator bit is false, do not evaluate the assertion
// This is okay since we are not enforcing any constraints
let false_boolean = Boolean::Constant(false);
if let Some(indicator_bool) = indicator {
if indicator_bool.eq(&false_boolean) {
return Ok(()); // continue execution
}
if !get_indicator_value(indicator) {
return Ok(()); // Continue execution.
}
// Unwrap assertion value and handle errors

23
compiler/src/console/console.rs
View File

@ -16,7 +16,7 @@
//! Evaluates a macro in a compiled Leo program.
use crate::{errors::ConsoleError, program::ConstrainedProgram, GroupType};
use crate::{errors::ConsoleError, program::ConstrainedProgram, statement::get_indicator_value, GroupType};
use leo_ast::{ConsoleFunction, ConsoleFunctionCall};
use snarkos_models::{
@ -30,7 +30,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
cs: &mut CS,
file_scope: &str,
function_scope: &str,
indicator: Option<Boolean>,
indicator: &Boolean,
console: ConsoleFunctionCall,
) -> Result<(), ConsoleError> {
match console.function {
@ -40,21 +40,21 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
ConsoleFunction::Debug(string) => {
let string = self.format(cs, file_scope, function_scope, string)?;
if unwrap_indicator_value(indicator) {
if get_indicator_value(indicator) {
tracing::debug!("{}", string);
}
}
ConsoleFunction::Error(string) => {
let string = self.format(cs, file_scope, function_scope, string)?;
if unwrap_indicator_value(indicator) {
if get_indicator_value(indicator) {
tracing::error!("{}", string);
}
}
ConsoleFunction::Log(string) => {
let string = self.format(cs, file_scope, function_scope, string)?;
if unwrap_indicator_value(indicator) {
if get_indicator_value(indicator) {
tracing::info!("{}", string);
}
}
@ -63,16 +63,3 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
Ok(())
}
}
// Return the indicator boolean gadget value or true if it is None
// This is okay since we are not enforcing any constraints
fn unwrap_indicator_value(indicator: Option<Boolean>) -> bool {
let false_boolean = Boolean::constant(false);
if let Some(indicator_bool) = indicator {
if indicator_bool.eq(&false_boolean) {
return false;
}
}
true
}

16
compiler/src/errors/statement.rs
View File

@ -135,6 +135,22 @@ impl StatementError {
Self::new_from_span(message, span)
}
pub fn multiple_returns(span: Span) -> Self {
let message = "This function returns multiple times and produces unreachable circuits with undefined behavior."
.to_string();
Self::new_from_span(message, span)
}
pub fn no_returns(expected: Type, span: Span) -> Self {
let message = format!(
"function expected `{}` return type but no valid branches returned a result",
expected
);
Self::new_from_span(message, span)
}
pub fn select_fail(first: String, second: String, span: Span) -> Self {
let message = format!(
"Conditional select gadget failed to select between `{}` or `{}`",

32
compiler/src/function/function.rs
View File

@ -23,11 +23,11 @@ use crate::{
GroupType,
};
use leo_ast::{Expression, Function, FunctionInput, Type};
use leo_ast::{Expression, Function, FunctionInput};
use snarkos_models::{
curves::{Field, PrimeField},
gadgets::r1cs::ConstraintSystem,
gadgets::{r1cs::ConstraintSystem, utilities::boolean::Boolean},
};
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
@ -46,7 +46,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
let mut_self = function.contains_mut_self();
// Store input values as new variables in resolved program
for (input_model, input_expression) in function.filter_self_inputs().iter().zip(input.into_iter()) {
for (input_model, input_expression) in function.filter_self_inputs().zip(input.into_iter()) {
let (name, value) = match input_model {
FunctionInput::InputKeyword(keyword) => {
let value =
@ -92,13 +92,14 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// Evaluate every statement in the function and save all potential results
let mut results = vec![];
let indicator = Boolean::constant(true);
for statement in function.block.statements.iter() {
let mut result = self.enforce_statement(
cs,
scope,
&function_name,
None,
&indicator,
statement.clone(),
function.output.clone(),
declared_circuit_reference,
@ -109,26 +110,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
}
// Conditionally select a result based on returned indicators
let mut return_values = ConstrainedValue::Tuple(vec![]);
Self::conditionally_select_result(cs, &mut return_values, results, &function.span)?;
if let ConstrainedValue::Tuple(ref returns) = return_values {
let return_types = match function.output {
Some(Type::Tuple(types)) => types.len(),
Some(_) => 1usize,
None => 0usize,
};
if return_types != returns.len() {
return Err(FunctionError::return_arguments_length(
return_types,
returns.len(),
function.span.clone(),
));
}
}
Ok(return_values)
Self::conditionally_select_result(cs, function.output, results, &function.span)
.map_err(FunctionError::StatementError)
}
}

7
compiler/src/function/input/input_section.rs
View File

@ -15,20 +15,21 @@
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use crate::{errors::FunctionError, ConstrainedCircuitMember, ConstrainedProgram, ConstrainedValue, GroupType};
use leo_ast::{Identifier, InputValue, Parameter};
use snarkos_models::{
curves::{Field, PrimeField},
gadgets::r1cs::ConstraintSystem,
};
use std::collections::HashMap;
use indexmap::IndexMap;
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn allocate_input_section<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
identifier: Identifier,
section: HashMap<Parameter, Option<InputValue>>,
section: IndexMap<Parameter, Option<InputValue>>,
) -> Result<ConstrainedValue<F, G>, FunctionError> {
let mut members = Vec::with_capacity(section.len());

100
compiler/src/function/result/result.rs
View File

@ -16,9 +16,16 @@
//! Enforces that one return value is produced in a compiled Leo program.
use crate::{errors::StatementError, program::ConstrainedProgram, value::ConstrainedValue, GroupType};
use crate::{
check_return_type,
errors::StatementError,
get_indicator_value,
program::ConstrainedProgram,
value::ConstrainedValue,
GroupType,
};
use leo_ast::Span;
use leo_ast::{Span, Type};
use snarkos_models::{
curves::{Field, PrimeField},
@ -29,49 +36,82 @@ use snarkos_models::{
};
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
/// iterates through a vector of results and selects one based off of indicators
///
/// Returns a conditionally selected result from the given possible function returns and
/// given function return type.
///
pub fn conditionally_select_result<CS: ConstraintSystem<F>>(
cs: &mut CS,
return_value: &mut ConstrainedValue<F, G>,
results: Vec<(Option<Boolean>, ConstrainedValue<F, G>)>,
expected_return: Option<Type>,
results: Vec<(Boolean, ConstrainedValue<F, G>)>,
span: &Span,
) -> Result<(), StatementError> {
// if there are no results, continue
) -> Result<ConstrainedValue<F, G>, StatementError> {
// Initialize empty return value.
let mut return_value = ConstrainedValue::Tuple(vec![]);
// If the function does not expect a return type, then make sure there are no returned results.
let return_type = match expected_return {
Some(return_type) => return_type,
None => {
if results.is_empty() {
return Ok(());
// If the function has no returns, then return an empty tuple.
return Ok(return_value);
} else {
return Err(StatementError::invalid_number_of_returns(
0,
results.len(),
span.to_owned(),
));
}
}
};
// Error if the function or one of its branches does not return.
if results
.iter()
.find(|(indicator, _res)| get_indicator_value(indicator))
.is_none()
{
return Err(StatementError::no_returns(return_type, span.to_owned()));
}
// If all indicators are none, then there are no branch conditions in the function.
// We simply return the last result.
// Find the return value
let mut ignored = vec![];
let mut found_return = false;
for (indicator, result) in results.into_iter() {
// Error if a statement returned a result with an incorrect type
let result_type = result.to_type(span)?;
check_return_type(&return_type, &result_type, span)?;
if results.iter().all(|(indicator, _res)| indicator.is_none()) {
let result = &results[results.len() - 1].1;
*return_value = result.clone();
return Ok(());
if get_indicator_value(&indicator) {
// Error if we already have a return value.
if found_return {
return Err(StatementError::multiple_returns(span.to_owned()));
} else {
// Set the function return value.
return_value = result;
found_return = true;
}
} else {
// Ignore a possible function return value.
ignored.push((indicator, result))
}
}
// Conditionally select out the ignored results in the circuit.
//
// If there are branches in the function we need to use the `ConditionalSelectGadget` to parse through and select the correct one.
// This can be thought of as de-multiplexing all previous wires that may have returned results into one.
for (i, (indicator, result)) in results.into_iter().enumerate() {
// Set the first value as the starting point
if i == 0 {
*return_value = result.clone();
}
let condition = indicator.unwrap_or(Boolean::Constant(true));
let selected_value = ConstrainedValue::conditionally_select(
cs.ns(|| format!("select {} {}:{}", result, span.line, span.start)),
&condition,
for (i, (indicator, result)) in ignored.into_iter().enumerate() {
return_value = ConstrainedValue::conditionally_select(
cs.ns(|| format!("select result {} {}:{}", i, span.line, span.start)),
&indicator,
&result,
return_value,
&return_value,
)
.map_err(|_| StatementError::select_fail(result.to_string(), return_value.to_string(), span.to_owned()))?;
*return_value = selected_value;
}
Ok(())
Ok(return_value)
}
}

6
compiler/src/program/program.rs
View File

@ -20,16 +20,16 @@ use crate::{value::ConstrainedValue, GroupType};
use snarkos_models::curves::{Field, PrimeField};
use std::collections::HashMap;
use indexmap::IndexMap;
pub struct ConstrainedProgram<F: Field + PrimeField, G: GroupType<F>> {
pub identifiers: HashMap<String, ConstrainedValue<F, G>>,
pub identifiers: IndexMap<String, ConstrainedValue<F, G>>,
}
impl<F: Field + PrimeField, G: GroupType<F>> Default for ConstrainedProgram<F, G> {
fn default() -> Self {
Self {
identifiers: HashMap::new(),
identifiers: IndexMap::new(),
}
}
}

8
compiler/src/statement/assign/array.rs
View File

@ -34,14 +34,12 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
cs: &mut CS,
file_scope: &str,
function_scope: &str,
indicator: Option<Boolean>,
indicator: &Boolean,
name: &str,
range_or_expression: RangeOrExpression,
mut new_value: ConstrainedValue<F, G>,
span: &Span,
) -> Result<(), StatementError> {
let condition = indicator.unwrap_or(Boolean::Constant(true));
// Resolve index so we know if we are assigning to a single value or a range of values
match range_or_expression {
RangeOrExpression::Expression(index) => {
@ -54,7 +52,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
let selected_value = ConstrainedValue::conditionally_select(
cs.ns(|| format!("select {} {}:{}", new_value, span.line, span.start)),
&condition,
indicator,
&new_value,
&old[index],
)
@ -90,7 +88,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
};
let selected_array = ConstrainedValue::conditionally_select(
cs.ns(|| format!("select {} {}:{}", new_array, span.line, span.start)),
&condition,
indicator,
&new_array,
old_array,
)

5
compiler/src/statement/assign/assign.rs
View File

@ -42,8 +42,8 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
file_scope: &str,
function_scope: &str,
declared_circuit_reference: &str,
indicator: &Boolean,
mut_self: bool,
indicator: Option<Boolean>,
assignee: Assignee,
expression: Expression,
span: &Span,
@ -56,14 +56,13 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// Mutate the old value into the new value
if assignee.accesses.is_empty() {
let condition = indicator.unwrap_or(Boolean::Constant(true));
let old_value = self.get_mutable_assignee(&variable_name, span)?;
new_value.resolve_type(Some(old_value.to_type(&span)?), span)?;
let selected_value = ConstrainedValue::conditionally_select(
cs.ns(|| format!("select {} {}:{}", new_value, span.line, span.start)),
&condition,
indicator,
&new_value,
old_value,
)

8
compiler/src/statement/assign/assignee.rs
View File

@ -34,7 +34,13 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// Check that assignee exists and is mutable
Ok(match self.get_mut(name) {
Some(value) => match value {
ConstrainedValue::Mutable(mutable_value) => mutable_value,
ConstrainedValue::Mutable(mutable_value) => {
// Get the mutable value.
mutable_value.get_inner_mut();
// Return the mutable value.
mutable_value
}
_ => return Err(StatementError::immutable_assign(name.to_owned(), span.to_owned())),
},
None => return Err(StatementError::undefined_variable(name.to_owned(), span.to_owned())),

6
compiler/src/statement/assign/circuit_variable.rs
View File

@ -31,14 +31,12 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn mutate_circuit_variable<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
indicator: Option<Boolean>,
indicator: &Boolean,
circuit_name: &str,
variable_name: Identifier,
mut new_value: ConstrainedValue<F, G>,
span: &Span,
) -> Result<ConstrainedValue<F, G>, StatementError> {
let condition = indicator.unwrap_or(Boolean::Constant(true));
// Get the mutable circuit by name
match self.get_mutable_assignee(circuit_name, span)? {
ConstrainedValue::CircuitExpression(_variable, members) => {
@ -68,7 +66,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// Conditionally select the value if this branch is executed.
let mut selected_value = ConstrainedValue::conditionally_select(
cs.ns(|| format!("select {} {}:{}", new_value, span.line, span.start)),
&condition,
indicator,
&new_value,
&member.1,
)

7
compiler/src/statement/assign/tuple.rs
View File

@ -31,15 +31,12 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn assign_tuple<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
indicator: Option<Boolean>,
indicator: &Boolean,
name: &str,
index: PositiveNumber,
mut new_value: ConstrainedValue<F, G>,
span: &Span,
) -> Result<(), StatementError> {
// Get the indicator value.
let condition = indicator.unwrap_or(Boolean::Constant(true));
// Parse the index.
let index_usize = parse_index(&index, &span)?;
@ -50,7 +47,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
let selected_value = ConstrainedValue::conditionally_select(
cs.ns(|| format!("select {} {}:{}", new_value, span.line, span.start)),
&condition,
indicator,
&new_value,
&old[index_usize],
)

5
compiler/src/statement/block/block.rs
View File

@ -33,9 +33,10 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
cs: &mut CS,
file_scope: &str,
function_scope: &str,
indicator: Option<Boolean>,
indicator: &Boolean,
block: Block,
return_type: Option<Type>,
declared_circuit_reference: &str,
mut_self: bool,
) -> StatementResult<Vec<IndicatorAndConstrainedValue<F, G>>> {
let mut results = Vec::with_capacity(block.statements.len());
@ -48,7 +49,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
indicator,
statement,
return_type.clone(),
"",
declared_circuit_reference,
mut_self,
)?;

20
compiler/src/statement/conditional/conditional.rs
View File

@ -49,16 +49,17 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
cs: &mut CS,
file_scope: &str,
function_scope: &str,
indicator: Option<Boolean>,
indicator: &Boolean,
statement: ConditionalStatement,
return_type: Option<Type>,
declared_circuit_reference: &str,
mut_self: bool,
span: &Span,
) -> StatementResult<Vec<IndicatorAndConstrainedValue<F, G>>> {
let statement_string = statement.to_string();
// Inherit the indicator from a previous conditional statement or assume that we are the outer parent
let outer_indicator = indicator.unwrap_or(Boolean::Constant(true));
// Inherit an indicator from a previous statement.
let outer_indicator = indicator;
// Evaluate the conditional boolean as the inner indicator
let inner_indicator = match self.enforce_expression(
@ -73,7 +74,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
};
// If outer_indicator && inner_indicator, then select branch 1
let outer_indicator_string = indicator_to_string(&outer_indicator);
let outer_indicator_string = indicator_to_string(outer_indicator);
let inner_indicator_string = indicator_to_string(&inner_indicator);
let branch_1_name = format!(
"branch indicator 1 {} && {}",
@ -81,7 +82,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
);
let branch_1_indicator = Boolean::and(
&mut cs.ns(|| format!("branch 1 {} {}:{}", statement_string, span.line, span.start)),
&outer_indicator,
outer_indicator,
&inner_indicator,
)
.map_err(|_| StatementError::indicator_calculation(branch_1_name, span.to_owned()))?;
@ -93,9 +94,10 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
cs,
file_scope,
function_scope,
Some(branch_1_indicator),
&branch_1_indicator,
statement.block,
return_type.clone(),
declared_circuit_reference,
mut_self,
)?;
@ -122,9 +124,10 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
cs,
file_scope,
function_scope,
Some(branch_2_indicator),
&branch_2_indicator,
*nested,
return_type,
declared_circuit_reference,
mut_self,
span,
)?,
@ -132,9 +135,10 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
cs,
file_scope,
function_scope,
Some(branch_2_indicator),
&branch_2_indicator,
block,
return_type,
declared_circuit_reference,
mut_self,
)?,
},

4
compiler/src/statement/iteration/iteration.rs
View File

@ -42,12 +42,13 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
cs: &mut CS,
file_scope: &str,
function_scope: &str,
indicator: Option<Boolean>,
indicator: &Boolean,
index: Identifier,
start: Expression,
stop: Expression,
block: Block,
return_type: Option<Type>,
declared_circuit_reference: &str,
mut_self: bool,
span: &Span,
) -> StatementResult<Vec<IndicatorAndConstrainedValue<F, G>>> {
@ -75,6 +76,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
indicator,
block.clone(),
return_type.clone(),
declared_circuit_reference,
mut_self,
)?;

21
compiler/src/statement/return_/return_.rs
View File

@ -24,20 +24,17 @@ use snarkos_models::{
gadgets::r1cs::ConstraintSystem,
};
fn check_return_type(expected: Option<Type>, actual: Type, span: &Span) -> Result<(), StatementError> {
match expected {
Some(expected) => {
/// Returns `Ok` if the expected type == actual type, returns `Err` otherwise.
pub fn check_return_type(expected: &Type, actual: &Type, span: &Span) -> Result<(), StatementError> {
if expected.ne(&actual) {
if (expected.is_self() && actual.is_circuit()) || expected.eq_flat(&actual) {
return Ok(());
// If the return type is `SelfType` returning the circuit type is okay.
return if (expected.is_self() && actual.is_circuit()) || expected.eq_flat(&actual) {
Ok(())
} else {
return Err(StatementError::arguments_type(&expected, &actual, span.to_owned()));
}
Err(StatementError::arguments_type(&expected, &actual, span.to_owned()))
};
}
Ok(())
}
None => Ok(()),
}
}
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
@ -53,7 +50,9 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
let result = self.enforce_operand(cs, file_scope, function_scope, return_type.clone(), expression, span)?;
// Make sure we return the correct type.
check_return_type(return_type, result.to_type(&span)?, span)?;
if let Some(expected) = return_type {
check_return_type(&expected, &result.to_type(span)?, span)?;
}
Ok(result)
}

25
compiler/src/statement/statement.rs
View File

@ -25,7 +25,7 @@ use snarkos_models::{
};
pub type StatementResult<T> = Result<T, StatementError>;
pub type IndicatorAndConstrainedValue<T, U> = (Option<Boolean>, ConstrainedValue<T, U>);
pub type IndicatorAndConstrainedValue<T, U> = (Boolean, ConstrainedValue<T, U>);
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
///
@ -41,7 +41,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
cs: &mut CS,
file_scope: &str,
function_scope: &str,
indicator: Option<Boolean>,
indicator: &Boolean,
statement: Statement,
return_type: Option<Type>,
declared_circuit_reference: &str,
@ -52,7 +52,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
match statement {
Statement::Return(expression, span) => {
let return_value = (
indicator,
indicator.to_owned(),
self.enforce_return_statement(cs, file_scope, function_scope, expression, return_type, &span)?,
);
@ -75,8 +75,8 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
file_scope,
function_scope,
declared_circuit_reference,
mut_self,
indicator,
mut_self,
variable,
expression,
&span,
@ -90,6 +90,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
indicator,
statement,
return_type,
declared_circuit_reference,
mut_self,
&span,
)?;
@ -107,6 +108,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
start_stop.1,
block,
return_type,
declared_circuit_reference,
mut_self,
&span,
)?;
@ -120,22 +122,25 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
let expression_string = expression.to_string();
let value = self.enforce_expression(cs, file_scope, function_scope, None, expression)?;
// handle empty return value cases
// Handle empty return value cases.
match &value {
ConstrainedValue::Tuple(values) => {
if !values.is_empty() {
return Err(StatementError::unassigned(expression_string, span));
results.push((*indicator, value));
}
}
_ => return Err(StatementError::unassigned(expression_string, span)),
}
let result = (indicator, value);
results.push(result);
}
};
Ok(results)
}
}
/// Returns the indicator boolean gadget value.
/// We can directly compare a boolean constant to the indicator since we are not enforcing any
/// constraints
pub fn get_indicator_value(indicator: &Boolean) -> bool {
indicator.eq(&Boolean::constant(true))
}

44
compiler/tests/address/mod.rs
View File

@ -22,72 +22,72 @@ static TEST_ADDRESS_2: &str = "aleo18qgam03qe483tdrcc3fkqwpp38ehff4a2xma6lu7hams
#[test]
fn test_valid() {
let bytes = include_bytes!("valid.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("valid.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program)
}
#[test]
fn test_invalid_prefix() {
let bytes = include_bytes!("invalid_prefix.leo");
let syntax_error = parse_program(bytes).is_err();
let program_string = include_str!("invalid_prefix.leo");
let syntax_error = parse_program(program_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_invalid_length() {
let bytes = include_bytes!("invalid_length.leo");
let syntax_error = parse_program(bytes).is_err();
let program_string = include_str!("invalid_length.leo");
let syntax_error = parse_program(program_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_empty() {
let bytes = include_bytes!("empty.leo");
let syntax_error = parse_program(bytes).is_err();
let program_string = include_str!("empty.leo");
let syntax_error = parse_program(program_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_implicit_valid() {
let bytes = include_bytes!("implicit_valid.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("implicit_valid.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_implicit_invalid() {
let bytes = include_bytes!("implicit_invalid.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("implicit_invalid.leo");
let program = parse_program(program_string).unwrap();
let _output = expect_compiler_error(program);
}
#[test]
fn test_console_assert_pass() {
let bytes = include_bytes!("console_assert_pass.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("console_assert_pass.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_console_assert_fail() {
let bytes = include_bytes!("console_assert_fail.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("console_assert_fail.leo");
let program = parse_program(program_string).unwrap();
let _output = expect_compiler_error(program);
}
#[test]
fn test_ternary() {
let bytes = include_bytes!("ternary.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("ternary.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("s", Some(InputValue::Boolean(true))),
@ -98,7 +98,7 @@ fn test_ternary() {
assert_satisfied(program);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("s", Some(InputValue::Boolean(false))),
@ -112,8 +112,8 @@ fn test_ternary() {
#[test]
fn test_equal() {
let bytes = include_bytes!("equal.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("equal.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Address(TEST_ADDRESS_1.to_string()))),
@ -125,7 +125,7 @@ fn test_equal() {
assert_satisfied(program);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Address(TEST_ADDRESS_1.to_string()))),

284
compiler/tests/array/mod.rs
View File

@ -41,17 +41,17 @@ pub fn output_zeros(program: EdwardsTestCompiler) {
#[test]
fn test_registers() {
let program_bytes = include_bytes!("registers.leo");
let ones_input_bytes = include_bytes!("input/registers_ones.in");
let zeros_input_bytes = include_bytes!("input/registers_zeros.in");
let program_string = include_str!("registers.leo");
let ones_input_string = include_str!("input/registers_ones.in");
let zeros_input_string = include_str!("input/registers_zeros.in");
// test ones input register => ones output register
let program = parse_program_with_input(program_bytes, ones_input_bytes).unwrap();
let program = parse_program_with_input(program_string, ones_input_string).unwrap();
output_ones(program);
// test zeros input register => zeros output register
let program = parse_program_with_input(program_bytes, zeros_input_bytes).unwrap();
let program = parse_program_with_input(program_string, zeros_input_string).unwrap();
output_zeros(program);
}
@ -60,171 +60,179 @@ fn test_registers() {
#[test]
fn test_inline() {
let program_bytes = include_bytes!("inline.leo");
let input_bytes = include_bytes!("input/three_ones.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("inline.leo");
let input_string = include_str!("input/three_ones.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_inline_fail() {
let program_bytes = include_bytes!("inline.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("inline.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_initializer() {
let program_bytes = include_bytes!("initializer.leo");
let input_bytes = include_bytes!("input/three_ones.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("initializer.leo");
let input_string = include_str!("input/three_ones.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_initializer_fail() {
let program_bytes = include_bytes!("initializer_fail.leo");
let input_bytes = include_bytes!("input/three_ones.in");
let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err();
let program_string = include_str!("initializer_fail.leo");
let input_string = include_str!("input/three_ones.in");
let syntax_error = parse_program_with_input(program_string, input_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_initializer_input() {
let program_bytes = include_bytes!("initializer_input.leo");
let input_bytes = include_bytes!("input/six_zeros.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("initializer_input.leo");
let input_string = include_str!("input/six_zeros.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_initializer_input_fail() {
let program_bytes = include_bytes!("initializer_input.leo");
let input_bytes = include_bytes!("input/initializer_fail.in");
let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err();
let program_string = include_str!("initializer_input.leo");
let input_string = include_str!("input/initializer_fail.in");
let syntax_error = parse_program_with_input(program_string, input_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_input_nested_3x2() {
let program_bytes = include_bytes!("input_nested_3x2.leo");
let input_bytes = include_bytes!("input/input_nested_3x2.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("input_nested_3x2.leo");
let input_string = include_str!("input/input_nested_3x2.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_input_nested_3x2_fail() {
let program_bytes = include_bytes!("input_nested_3x2_fail.leo");
let input_bytes = include_bytes!("input/input_nested_3x2_fail.in");
let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err();
let program_string = include_str!("input_nested_3x2_fail.leo");
let input_string = include_str!("input/input_nested_3x2_fail.in");
let syntax_error = parse_program_with_input(program_string, input_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_input_tuple_3x2() {
let program_bytes = include_bytes!("input_tuple_3x2.leo");
let input_bytes = include_bytes!("input/input_tuple_3x2.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("input_tuple_3x2.leo");
let input_string = include_str!("input/input_tuple_3x2.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_input_tuple_3x2_fail() {
let program_bytes = include_bytes!("input_tuple_3x2_fail.leo");
let input_bytes = include_bytes!("input/input_tuple_3x2_fail.in");
let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err();
let program_string = include_str!("input_tuple_3x2_fail.leo");
let input_string = include_str!("input/input_tuple_3x2_fail.in");
let syntax_error = parse_program_with_input(program_string, input_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_multi_fail_initializer() {
let program_bytes = include_bytes!("multi_fail_initializer.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("multi_fail_initializer.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_multi_inline_fail() {
let program_bytes = include_bytes!("multi_fail_inline.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("multi_fail_inline.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_multi_initializer() {
let program_bytes = include_bytes!("multi_initializer.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("multi_initializer.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_multi_initializer_fail() {
let program_bytes = include_bytes!("multi_initializer_fail.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("multi_initializer_fail.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_nested_3x2_value() {
let program_bytes = include_bytes!("nested_3x2_value.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("nested_3x2_value.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_nested_3x2_value_fail() {
let program_bytes = include_bytes!("nested_3x2_value_fail.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("nested_3x2_value_fail.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_tuple_3x2_value() {
let program_bytes = include_bytes!("tuple_3x2_value.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("tuple_3x2_value.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_tuple_3x2_value_fail() {
let program_bytes = include_bytes!("tuple_3x2_value_fail.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("tuple_3x2_value_fail.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_spread() {
let program_bytes = include_bytes!("spread.leo");
let input_bytes = include_bytes!("input/three_ones.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("spread.leo");
let input_string = include_str!("input/three_ones.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_slice() {
let program_bytes = include_bytes!("slice.leo");
let input_bytes = include_bytes!("input/three_ones.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("slice.leo");
let input_string = include_str!("input/three_ones.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_slice_lower() {
let program_string = include_str!("slice_lower.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
@ -233,136 +241,136 @@ fn test_slice() {
#[test]
fn test_type_fail() {
let program_bytes = include_bytes!("type_fail.leo");
let syntax_error = parse_program(program_bytes).is_err();
let program_string = include_str!("type_fail.leo");
let syntax_error = parse_program(program_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_type_nested_value_nested_3x2() {
let program_bytes = include_bytes!("type_nested_value_nested_3x2.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_nested_value_nested_3x2.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_type_nested_value_nested_3x2_fail() {
let program_bytes = include_bytes!("type_nested_value_nested_3x2_fail.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_nested_value_nested_3x2_fail.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_type_nested_value_nested_4x3x2() {
let program_bytes = include_bytes!("type_nested_value_nested_4x3x2.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_nested_value_nested_4x3x2.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_type_nested_value_nested_4x3x2_fail() {
let program_bytes = include_bytes!("type_nested_value_nested_4x3x2_fail.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_nested_value_nested_4x3x2_fail.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_type_nested_value_tuple_3x2() {
let program_bytes = include_bytes!("type_nested_value_tuple_3x2.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_nested_value_tuple_3x2.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_type_nested_value_tuple_3x2_fail() {
let program_bytes = include_bytes!("type_nested_value_tuple_3x2_fail.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_nested_value_tuple_3x2_fail.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_type_nested_value_tuple_4x3x2() {
let program_bytes = include_bytes!("type_nested_value_tuple_4x3x2.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_nested_value_tuple_4x3x2.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_type_nested_value_tuple_4x3x2_fail() {
let program_bytes = include_bytes!("type_nested_value_tuple_4x3x2_fail.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_nested_value_tuple_4x3x2_fail.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_type_tuple_value_nested_3x2() {
let program_bytes = include_bytes!("type_tuple_value_nested_3x2.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_tuple_value_nested_3x2.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_type_tuple_value_nested_3x2_fail() {
let program_bytes = include_bytes!("type_tuple_value_nested_3x2_fail.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_tuple_value_nested_3x2_fail.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_type_tuple_value_nested_4x3x2() {
let program_bytes = include_bytes!("type_tuple_value_nested_4x3x2.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_tuple_value_nested_4x3x2.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_type_tuple_value_nested_4x3x2_fail() {
let program_bytes = include_bytes!("type_tuple_value_nested_4x3x2_fail.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_tuple_value_nested_4x3x2_fail.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_type_tuple_value_tuple_3x2() {
let program_bytes = include_bytes!("type_tuple_value_tuple_3x2.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_tuple_value_tuple_3x2.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_type_tuple_value_tuple_3x2_fail() {
let program_bytes = include_bytes!("type_tuple_value_tuple_3x2_fail.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_tuple_value_tuple_3x2_fail.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_type_tuple_value_tuple_4x3x2() {
let program_bytes = include_bytes!("type_tuple_value_tuple_4x3x2.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_tuple_value_tuple_4x3x2.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_type_tuple_value_tuple_4x3x2_fail() {
let program_bytes = include_bytes!("type_tuple_value_tuple_4x3x2_fail.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("type_tuple_value_tuple_4x3x2_fail.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
@ -371,72 +379,72 @@ fn test_type_tuple_value_tuple_4x3x2_fail() {
#[test]
fn test_input_type_nested_value_nested_3x2() {
let program_bytes = include_bytes!("type_input_3x2.leo");
let input_bytes = include_bytes!("input/type_nested_value_nested_3x2.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("type_input_3x2.leo");
let input_string = include_str!("input/type_nested_value_nested_3x2.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_input_type_nested_value_nested_3x2_fail() {
let program_bytes = include_bytes!("type_input_3x2.leo");
let input_bytes = include_bytes!("input/type_nested_value_nested_3x2_fail.in");
let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err();
let program_string = include_str!("type_input_3x2.leo");
let input_string = include_str!("input/type_nested_value_nested_3x2_fail.in");
let syntax_error = parse_program_with_input(program_string, input_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_input_type_nested_value_nested_4x3x2() {
let program_bytes = include_bytes!("type_input_4x3x2.leo");
let input_bytes = include_bytes!("input/type_nested_value_nested_4x3x2.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("type_input_4x3x2.leo");
let input_string = include_str!("input/type_nested_value_nested_4x3x2.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_input_type_nested_value_nested_4x3x2_fail() {
let program_bytes = include_bytes!("type_input_4x3x2.leo");
let input_bytes = include_bytes!("input/type_nested_value_nested_4x3x2_fail.in");
let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err();
let program_string = include_str!("type_input_4x3x2.leo");
let input_string = include_str!("input/type_nested_value_nested_4x3x2_fail.in");
let syntax_error = parse_program_with_input(program_string, input_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_input_type_nested_value_tuple_3x2() {
let program_bytes = include_bytes!("type_input_3x2.leo");
let input_bytes = include_bytes!("input/type_nested_value_tuple_3x2.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("type_input_3x2.leo");
let input_string = include_str!("input/type_nested_value_tuple_3x2.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_input_type_nested_value_tuple_3x2_fail() {
let program_bytes = include_bytes!("type_input_3x2.leo");
let input_bytes = include_bytes!("input/type_nested_value_tuple_3x2_fail.in");
let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err();
let program_string = include_str!("type_input_3x2.leo");
let input_string = include_str!("input/type_nested_value_tuple_3x2_fail.in");
let syntax_error = parse_program_with_input(program_string, input_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_input_type_nested_value_tuple_4x3x2() {
let program_bytes = include_bytes!("type_input_4x3x2.leo");
let input_bytes = include_bytes!("input/type_nested_value_tuple_4x3x2.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("type_input_4x3x2.leo");
let input_string = include_str!("input/type_nested_value_tuple_4x3x2.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program)
}
#[test]
fn test_input_type_nested_value_tuple_4x3x2_fail() {
let program_bytes = include_bytes!("type_input_4x3x2.leo");
let input_bytes = include_bytes!("input/type_nested_value_tuple_4x3x2_fail.in");
let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err();
let program_string = include_str!("type_input_4x3x2.leo");
let input_string = include_str!("input/type_nested_value_tuple_4x3x2_fail.in");
let syntax_error = parse_program_with_input(program_string, input_string).is_err();
assert!(syntax_error);
}
@ -445,72 +453,72 @@ fn test_input_type_nested_value_tuple_4x3x2_fail() {
#[test]
fn test_input_type_tuple_value_nested_3x2() {
let program_bytes = include_bytes!("type_input_3x2.leo");
let input_bytes = include_bytes!("input/type_tuple_value_nested_3x2.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("type_input_3x2.leo");
let input_string = include_str!("input/type_tuple_value_nested_3x2.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_input_type_tuple_value_nested_3x2_fail() {
let program_bytes = include_bytes!("type_input_3x2.leo");
let input_bytes = include_bytes!("input/type_tuple_value_nested_3x2_fail.in");
let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err();
let program_string = include_str!("type_input_3x2.leo");
let input_string = include_str!("input/type_tuple_value_nested_3x2_fail.in");
let syntax_error = parse_program_with_input(program_string, input_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_input_type_tuple_value_nested_4x3x2() {
let program_bytes = include_bytes!("type_input_4x3x2.leo");
let input_bytes = include_bytes!("input/type_tuple_value_nested_4x3x2.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("type_input_4x3x2.leo");
let input_string = include_str!("input/type_tuple_value_nested_4x3x2.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_input_type_tuple_value_nested_4x3x2_fail() {
let program_bytes = include_bytes!("type_input_4x3x2.leo");
let input_bytes = include_bytes!("input/type_tuple_value_nested_4x3x2_fail.in");
let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err();
let program_string = include_str!("type_input_4x3x2.leo");
let input_string = include_str!("input/type_tuple_value_nested_4x3x2_fail.in");
let syntax_error = parse_program_with_input(program_string, input_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_input_type_tuple_value_tuple_3x2() {
let program_bytes = include_bytes!("type_input_3x2.leo");
let input_bytes = include_bytes!("input/type_tuple_value_tuple_3x2.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("type_input_3x2.leo");
let input_string = include_str!("input/type_tuple_value_tuple_3x2.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_input_type_tuple_value_tuple_3x2_fail() {
let program_bytes = include_bytes!("type_input_3x2.leo");
let input_bytes = include_bytes!("input/type_tuple_value_tuple_3x2_fail.in");
let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err();
let program_string = include_str!("type_input_3x2.leo");
let input_string = include_str!("input/type_tuple_value_tuple_3x2_fail.in");
let syntax_error = parse_program_with_input(program_string, input_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_input_type_tuple_value_tuple_4x3x2() {
let program_bytes = include_bytes!("type_input_4x3x2.leo");
let input_bytes = include_bytes!("input/type_tuple_value_tuple_4x3x2.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program_string = include_str!("type_input_4x3x2.leo");
let input_string = include_str!("input/type_tuple_value_tuple_4x3x2.in");
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_input_type_tuple_value_tuple_4x3x2_fail() {
let program_bytes = include_bytes!("type_input_4x3x2.leo");
let input_bytes = include_bytes!("input/type_tuple_value_tuple_4x3x2_fail.in");
let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err();
let program_string = include_str!("type_input_4x3x2.leo");
let input_string = include_str!("input/type_tuple_value_tuple_4x3x2_fail.in");
let syntax_error = parse_program_with_input(program_string, input_string).is_err();
assert!(syntax_error);
}

8
compiler/tests/array/slice_lower.leo Normal file
View File

@ -0,0 +1,8 @@
function main() {
let arr: [u32; 9] = [0, 1, 2, 3, 4, 5, 6, 7, 8];
let expected: [u32; 2] = [0, 1];
let actual = arr[..2]; // Should produce [0, 1]
console.assert(expected == actual);
}

3
compiler/tests/array/spread.leo
View File

@ -1,6 +1,7 @@
// A spread operator `...` copies the elements of one array into another
function main(a: [u8; 3]) {
let b = [1u8, 1u8];
let c = [1u8, ...b];
console.assert(a == [1u8, ...b]);
console.assert(a == c);
}

74
compiler/tests/boolean/mod.rs
View File

@ -40,37 +40,37 @@ pub fn output_false(program: EdwardsTestCompiler) {
#[test]
fn test_input_pass() {
let program_bytes = include_bytes!("assert_eq_input.leo");
let input_bytes = include_bytes!("input/true_true.in");
let program_string = include_str!("assert_eq_input.leo");
let input_string = include_str!("input/true_true.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_input_fail() {
let program_bytes = include_bytes!("assert_eq_input.leo");
let input_bytes = include_bytes!("input/true_false.in");
let program_string = include_str!("assert_eq_input.leo");
let input_string = include_str!("input/true_false.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program = parse_program_with_input(program_string, input_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_registers() {
let program_bytes = include_bytes!("output_register.leo");
let true_input_bytes = include_bytes!("input/registers_true.in");
let false_input_bytes = include_bytes!("input/registers_false.in");
let program_string = include_str!("output_register.leo");
let true_input_string = include_str!("input/registers_true.in");
let false_input_string = include_str!("input/registers_false.in");
// test true input register => true output register
let program = parse_program_with_input(program_bytes, true_input_bytes).unwrap();
let program = parse_program_with_input(program_string, true_input_string).unwrap();
output_true(program);
// test false input register => false output register
let program = parse_program_with_input(program_bytes, false_input_bytes).unwrap();
let program = parse_program_with_input(program_string, false_input_string).unwrap();
output_false(program);
}
@ -79,32 +79,32 @@ fn test_registers() {
#[test]
fn test_not_true() {
let bytes = include_bytes!("not_true.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("not_true.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_not_false() {
let bytes = include_bytes!("not_false.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("not_false.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_not_mutable() {
let bytes = include_bytes!("not_mutable.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("not_mutable.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_not_u32() {
let bytes = include_bytes!("not_u32.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("not_u32.leo");
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
@ -113,32 +113,32 @@ fn test_not_u32() {
#[test]
fn test_true_or_true() {
let bytes = include_bytes!("true_or_true.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("true_or_true.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_true_or_false() {
let bytes = include_bytes!("true_or_false.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("true_or_false.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_false_or_false() {
let bytes = include_bytes!("false_or_false.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("false_or_false.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_true_or_u32() {
let bytes = include_bytes!("true_or_u32.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("true_or_u32.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
@ -147,32 +147,32 @@ fn test_true_or_u32() {
#[test]
fn test_true_and_true() {
let bytes = include_bytes!("true_and_true.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("true_and_true.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_true_and_false() {
let bytes = include_bytes!("true_and_false.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("true_and_false.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_false_and_false() {
let bytes = include_bytes!("false_and_false.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("false_and_false.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_true_and_u32() {
let bytes = include_bytes!("true_and_u32.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("true_and_u32.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
@ -181,8 +181,8 @@ fn test_true_and_u32() {
#[test]
fn test_all() {
let bytes = include_bytes!("all.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("all.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}

2
compiler/tests/circuits/member_static_function_invalid.leo
View File

@ -5,5 +5,5 @@ circuit Foo {
}
function main() {
let err = Foo::echo(1u32); // Correct, echo is a static function and must be accessed using `::`
let err = Foo.echo(1u32); // Invalid, echo is a static function and must be accessed using `::`
}

122
compiler/tests/circuits/mod.rs
View File

@ -20,24 +20,24 @@ use crate::{assert_satisfied, expect_compiler_error, expect_type_inference_error
#[test]
fn test_inline() {
let bytes = include_bytes!("inline.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("inline.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_inline_fail() {
let bytes = include_bytes!("inline_fail.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("inline_fail.leo");
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_inline_undefined() {
let bytes = include_bytes!("inline_undefined.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("inline_undefined.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
@ -46,88 +46,88 @@ fn test_inline_undefined() {
#[test]
fn test_member_variable() {
let bytes = include_bytes!("member_variable.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("member_variable.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_member_variable_fail() {
let bytes = include_bytes!("member_variable_fail.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("member_variable_fail.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
#[test]
fn test_member_variable_and_function() {
let bytes = include_bytes!("member_variable_and_function.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("member_variable_and_function.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_member_function() {
let bytes = include_bytes!("member_function.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("member_function.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_member_function_fail() {
let bytes = include_bytes!("member_function_fail.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("member_function_fail.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
#[test]
fn test_member_function_invalid() {
let bytes = include_bytes!("member_function_invalid.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("member_function_invalid.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
#[test]
fn test_member_function_nested() {
let bytes = include_bytes!("member_function_nested.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("member_function_nested.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_member_static_function() {
let bytes = include_bytes!("member_static_function.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("member_static_function.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_member_static_function_nested() {
let bytes = include_bytes!("member_static_function_nested.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("member_static_function_nested.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_member_static_function_invalid() {
let bytes = include_bytes!("member_static_function_invalid.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("member_static_function_invalid.leo");
let error = parse_program(program_string).err().unwrap();
assert_satisfied(program)
expect_type_inference_error(error)
}
#[test]
fn test_member_static_function_undefined() {
let bytes = include_bytes!("member_static_function_undefined.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("member_static_function_undefined.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error)
}
@ -136,64 +136,72 @@ fn test_member_static_function_undefined() {
#[test]
fn test_mutate_function_fail() {
let bytes = include_bytes!("mut_function_fail.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("mut_function_fail.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
#[test]
fn test_mutate_self_variable() {
let bytes = include_bytes!("mut_self_variable.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("mut_self_variable.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_mutate_self_variable_conditional() {
let program_string = include_str!("mut_self_variable_conditional.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_mutate_self_variable_fail() {
let bytes = include_bytes!("mut_self_variable_fail.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("mut_self_variable_fail.leo");
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_mutate_self_function_fail() {
let bytes = include_bytes!("mut_self_function_fail.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("mut_self_function_fail.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
#[test]
fn test_mutate_self_static_function_fail() {
let bytes = include_bytes!("mut_self_static_function_fail.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("mut_self_static_function_fail.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
#[test]
fn test_mutate_static_function_fail() {
let bytes = include_bytes!("mut_static_function_fail.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("mut_static_function_fail.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
#[test]
fn test_mutate_variable() {
let bytes = include_bytes!("mut_variable.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("mut_variable.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_mutate_variable_fail() {
let bytes = include_bytes!("mut_variable_fail.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("mut_variable_fail.leo");
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
@ -202,32 +210,32 @@ fn test_mutate_variable_fail() {
#[test]
fn test_self_fail() {
let bytes = include_bytes!("self_fail.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("self_fail.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
#[test]
fn test_self_member_pass() {
let bytes = include_bytes!("self_member.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("self_member.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_self_member_invalid() {
let bytes = include_bytes!("self_member_invalid.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("self_member_invalid.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
#[test]
fn test_self_member_undefined() {
let bytes = include_bytes!("self_member_undefined.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("self_member_undefined.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
@ -236,16 +244,16 @@ fn test_self_member_undefined() {
#[test]
fn test_pedersen_mock() {
let bytes = include_bytes!("pedersen_mock.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("pedersen_mock.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_define_circuit_inside_circuit_function() {
let bytes = include_bytes!("define_circuit_inside_circuit_function.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("define_circuit_inside_circuit_function.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}

15
compiler/tests/circuits/mut_self_variable_conditional.leo Normal file
View File

@ -0,0 +1,15 @@
function main() {
let mut f = Foo { a: 0u32 };
f.bar();
}
circuit Foo {
a: u32
function bar(mut self) {
if true {
self.a = 5u32; // Mutating a variable inside a conditional statement should work.
}
}
}

3
compiler/tests/compiler/main.leo Normal file
View File

@ -0,0 +1,3 @@
function main() {
let a: u32 = 1 + 2;
}

46
compiler/tests/compiler/mod.rs Normal file
View File

@ -0,0 +1,46 @@
// Copyright (C) 2019-2020 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use crate::{assert_satisfied, get_output, parse_program, EdwardsTestCompiler};
use std::{env::current_dir, path::PathBuf};
static MAIN_FILE_NAME: &str = "tests/compiler/main.leo";
// Compiler tests rely on knowledge of local directories. They should be run locally only.
#[test]
#[ignore]
fn test_parse_program_from_string() {
// Parse program from string with compiler.
let program_string = include_str!("main.leo");
let mut compiler_no_path = EdwardsTestCompiler::new("".to_string(), PathBuf::new(), PathBuf::new());
compiler_no_path.parse_program_from_string(program_string).unwrap();
// Parse program from file path with compiler.
let mut local = current_dir().unwrap();
local.push(MAIN_FILE_NAME);
let compiler_with_path =
EdwardsTestCompiler::parse_program_without_input("".to_string(), local, PathBuf::new()).unwrap();
// Compare output bytes.
let expected_output = get_output(compiler_no_path);
let actual_output = get_output(compiler_with_path);
assert_eq!(expected_output, actual_output);
}

52
compiler/tests/console/mod.rs
View File

@ -19,63 +19,63 @@ use leo_ast::InputValue;
#[test]
fn test_log() {
let bytes = include_bytes!("log.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("log.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_log_fail() {
let bytes = include_bytes!("log_fail.leo");
let program_string = include_str!("log_fail.leo");
assert!(parse_program(bytes).is_err());
assert!(parse_program(program_string).is_err());
}
#[test]
fn test_log_parameter() {
let bytes = include_bytes!("log_parameter.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("log_parameter.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_log_parameter_many() {
let bytes = include_bytes!("log_parameter_many.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("log_parameter_many.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_log_parameter_fail_unknown() {
let bytes = include_bytes!("log_parameter_fail_unknown.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("log_parameter_fail_unknown.leo");
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_log_parameter_fail_empty() {
let bytes = include_bytes!("log_parameter_fail_empty.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("log_parameter_fail_empty.leo");
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_log_parameter_fail_none() {
let bytes = include_bytes!("log_parameter_fail_empty.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("log_parameter_fail_empty.leo");
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_log_input() {
let bytes = include_bytes!("log_input.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("log_input.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(true)))]);
@ -88,8 +88,8 @@ fn test_log_input() {
#[test]
fn test_debug() {
let bytes = include_bytes!("debug.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("debug.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
@ -98,8 +98,8 @@ fn test_debug() {
#[test]
fn test_error() {
let bytes = include_bytes!("error.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("error.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
@ -108,8 +108,8 @@ fn test_error() {
#[test]
fn test_assert() {
let bytes = include_bytes!("assert.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("assert.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(true)))]);
@ -117,7 +117,7 @@ fn test_assert() {
assert_satisfied(program);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(false)))]);
@ -128,15 +128,15 @@ fn test_assert() {
#[test]
fn test_conditional_assert() {
let bytes = include_bytes!("conditional_assert.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("conditional_assert.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(true)))]);
program.set_main_input(main_input);
assert_satisfied(program);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(false)))]);

22
compiler/tests/core/mod.rs
View File

@ -20,40 +20,40 @@ use crate::{assert_satisfied, expect_symbol_table_error, parse_program};
#[test]
fn test_core_circuit_invalid() {
let program_bytes = include_bytes!("core_package_invalid.leo");
let program = parse_program(program_bytes).err().unwrap();
let program_string = include_str!("core_package_invalid.leo");
let error = parse_program(program_string).err().unwrap();
expect_symbol_table_error(program);
expect_symbol_table_error(error);
}
#[test]
fn test_core_circuit_star_fail() {
let program_bytes = include_bytes!("core_circuit_star_fail.leo");
let error = parse_program(program_bytes).err().unwrap();
let program_string = include_str!("core_circuit_star_fail.leo");
let error = parse_program(program_string).err().unwrap();
expect_symbol_table_error(error);
}
#[test]
fn test_core_package_invalid() {
let program_bytes = include_bytes!("core_package_invalid.leo");
let error = parse_program(program_bytes).err().unwrap();
let program_string = include_str!("core_package_invalid.leo");
let error = parse_program(program_string).err().unwrap();
expect_symbol_table_error(error);
}
#[test]
fn test_core_unstable_package_invalid() {
let program_bytes = include_bytes!("core_unstable_package_invalid.leo");
let error = parse_program(program_bytes).err().unwrap();
let program_string = include_str!("core_unstable_package_invalid.leo");
let error = parse_program(program_string).err().unwrap();
expect_symbol_table_error(error);
}
#[test]
fn test_unstable_blake2s_sanity() {
let program_bytes = include_bytes!("unstable_blake2s.leo");
let program = parse_program(program_bytes).unwrap();
let program_string = include_str!("unstable_blake2s.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}

23
compiler/tests/core/packages/unstable/blake2s/mod.rs
View File

@ -32,33 +32,32 @@ use snarkos_models::algorithms::PRF;
#[test]
fn test_arguments_length_fail() {
let program_bytes = include_bytes!("arguments_length_fail.leo");
let error = parse_program(program_bytes).err().unwrap();
let program_string = include_str!("arguments_length_fail.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
#[test]
fn test_arguments_type_fail() {
let program_bytes = include_bytes!("arguments_type_fail.leo");
let error = parse_program(program_bytes).err().unwrap();
let program_string = include_str!("arguments_type_fail.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
#[test]
fn test_blake2s_input() {
let input_bytes = include_bytes!("inputs/valid_input.in");
let program_bytes = include_bytes!("blake2s_input.leo");
let expected_bytes = include_bytes!("outputs/valid_output.out");
let input_string = include_str!("inputs/valid_input.in");
let program_string = include_str!("blake2s_input.leo");
let expected_string = include_str!("outputs/valid_output.out");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program = parse_program_with_input(program_string, input_string).unwrap();
let expected = std::str::from_utf8(expected_bytes).unwrap();
let actual_bytes = get_output(program);
let actual = std::str::from_utf8(actual_bytes.bytes().as_slice()).unwrap();
let actual_string = std::str::from_utf8(actual_bytes.bytes().as_slice()).unwrap();
assert_eq!(expected, actual)
assert_eq!(expected_string, actual_string)
}
#[test]
@ -81,7 +80,7 @@ fn test_blake2s_random() {
// The `blake2s_random.leo` program will compute a blake2s hash digest and compare it against
// the expected value
let bytes = include_bytes!("blake2s_random.leo");
let bytes = include_str!("blake2s_random.leo");
let mut program = parse_program(bytes).unwrap();
let main_input = generate_main_input(vec![

8
compiler/tests/definition/mod.rs
View File

@ -18,9 +18,9 @@ use crate::{assert_satisfied, import::set_local_dir, parse_program};
#[test]
fn test_out_of_order() {
let program_bytes = include_bytes!("out_of_order.leo");
let program_string = include_str!("out_of_order.leo");
let program = parse_program(program_bytes).unwrap();
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
@ -30,9 +30,9 @@ fn test_out_of_order() {
fn test_out_of_order_with_import() {
set_local_dir();
let program_bytes = include_bytes!("out_of_order_with_import.leo");
let program_string = include_str!("out_of_order_with_import.leo");
let program = parse_program(program_bytes).unwrap();
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}

54
compiler/tests/field/mod.rs
View File

@ -52,8 +52,8 @@ fn test_negate() {
let a_string = field_to_decimal_string(a);
let b_string = field_to_decimal_string(b);
let bytes = include_bytes!("negate.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("negate.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Field(a_string))),
@ -81,8 +81,8 @@ fn test_add() {
let b_string = field_to_decimal_string(b);
let c_string = field_to_decimal_string(c);
let bytes = include_bytes!("add.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("add.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Field(a_string))),
@ -111,8 +111,8 @@ fn test_sub() {
let b_string = field_to_decimal_string(b);
let c_string = field_to_decimal_string(c);
let bytes = include_bytes!("sub.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("sub.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Field(a_string))),
@ -140,8 +140,8 @@ fn test_div() {
let b_string = field_to_decimal_string(b);
let c_string = field_to_decimal_string(c);
let bytes = include_bytes!("div.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("div.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Field(a_string))),
@ -169,8 +169,8 @@ fn test_mul() {
let b_string = field_to_decimal_string(b);
let c_string = field_to_decimal_string(c);
let bytes = include_bytes!("mul.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("mul.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Field(a_string))),
@ -197,8 +197,8 @@ fn test_eq() {
// test equal
let bytes = include_bytes!("eq.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("eq.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Field(a_string.clone()))),
@ -214,7 +214,7 @@ fn test_eq() {
let c = a.eq(&b);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Field(a_string))),
@ -237,8 +237,8 @@ fn test_console_assert_pass() {
let a_string = field_to_decimal_string(a);
let bytes = include_bytes!("console_assert.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("console_assert.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Field(a_string.clone()))),
@ -266,8 +266,8 @@ fn test_console_assert_fail() {
let a_string = field_to_decimal_string(a);
let b_string = field_to_decimal_string(b);
let bytes = include_bytes!("console_assert.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("console_assert.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Field(a_string))),
@ -290,8 +290,8 @@ fn test_ternary() {
let a_string = field_to_decimal_string(a);
let b_string = field_to_decimal_string(b);
let bytes = include_bytes!("ternary.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("ternary.leo");
let mut program = parse_program(program_string).unwrap();
// true -> field a
let main_input = generate_main_input(vec![
@ -305,7 +305,7 @@ fn test_ternary() {
assert_satisfied(program);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
// false -> field b
let main_input = generate_main_input(vec![
@ -322,24 +322,24 @@ fn test_ternary() {
//
// pub fn output_one(program: EdwardsTestCompiler) {
// let expected = include_bytes!("output_/register_one.out");
// let expected = include_str!("output_/register_one.out");
// let actual = get_output(program);
//
// assert_eq!(expected, actual.bytes().as_slice());
// assert_eq!(expected, actual.program_string().as_slice());
// }
//
// pub fn output_zero(program: EdwardsTestCompiler) {
// let expected = include_bytes!("output_/register_zero.out");
// let expected = include_str!("output_/register_zero.out");
// let actual = get_output(program);
//
// assert_eq!(expected, actual.bytes().as_slice());
// assert_eq!(expected, actual.program_string().as_slice());
// }
//
// #[test]
// fn test_registers() {
// let program_bytes = include_bytes!("output_register.leo");
// let one_input_bytes = include_bytes!("input/register_one.in");
// let zero_input_bytes = include_bytes!("input/register_zero.in");
// let program_bytes = include_str!("output_register.leo");
// let one_input_bytes = include_str!("input/register_one.in");
// let zero_input_bytes = include_str!("input/register_zero.in");
//
// // test 1field input register => 1field output register
// let program = parse_program_with_input(program_bytes, one_input_bytes).unwrap();

106
compiler/tests/function/mod.rs
View File

@ -26,85 +26,99 @@ use leo_compiler::errors::{CompilerError, ExpressionError, FunctionError, Statem
#[test]
fn test_empty() {
let bytes = include_bytes!("empty.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("empty.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_iteration() {
let bytes = include_bytes!("iteration.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("iteration.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_iteration_repeated() {
let bytes = include_bytes!("iteration_repeated.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("iteration_repeated.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_newlines() {
let input_bytes = include_bytes!("input/newlines.in");
let program_bytes = include_bytes!("newlines.leo");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let input_string = include_str!("input/newlines.in");
let program_string = include_str!("newlines.leo");
let program = parse_program_with_input(program_string, input_string).unwrap();
let expected_bytes = include_bytes!("output/newlines.out");
let expected = std::str::from_utf8(expected_bytes).unwrap();
let expected_string = include_str!("output/newlines.out");
let actual_bytes = get_output(program);
let actual = std::str::from_utf8(actual_bytes.bytes().as_slice()).unwrap();
let actual_string = std::str::from_utf8(actual_bytes.bytes().as_slice()).unwrap();
assert_eq!(expected, actual);
assert_eq!(expected_string, actual_string);
}
#[test]
fn test_multiple_returns() {
let bytes = include_bytes!("multiple.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("multiple_returns.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_multiple_returns_fail() {
let program_string = include_str!("multiple_returns_fail.leo");
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_multiple_returns_fail_conditional() {
let program_string = include_str!("multiple_returns_fail_conditional.leo");
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_multiple_returns_main() {
let program_bytes = include_bytes!("multiple_main.leo");
let input_bytes = include_bytes!("input/registers.in");
let program_string = include_str!("multiple_returns_main.leo");
let input_string = include_str!("input/registers.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program = parse_program_with_input(program_string, input_string).unwrap();
let expected_bytes = include_bytes!("output/registers.out");
let expected = std::str::from_utf8(expected_bytes).unwrap();
let expected_string = include_str!("output/registers.out");
let actual_bytes = get_output(program);
let actual = std::str::from_utf8(actual_bytes.bytes().as_slice()).unwrap();
let actual_string = std::str::from_utf8(actual_bytes.bytes().as_slice()).unwrap();
assert_eq!(expected, actual);
assert_eq!(expected_string, actual_string);
}
#[test]
fn test_repeated_function_call() {
let bytes = include_bytes!("repeated.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("repeated.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_return() {
let bytes = include_bytes!("return.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("return.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_scope_fail() {
let bytes = include_bytes!("scope_fail.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("scope_fail.leo");
let program = parse_program(program_string).unwrap();
match expect_compiler_error(program) {
CompilerError::FunctionError(FunctionError::StatementError(StatementError::ExpressionError(
@ -119,24 +133,24 @@ fn test_scope_fail() {
#[test]
fn test_undefined() {
let bytes = include_bytes!("undefined.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("undefined.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
#[test]
fn test_value_unchanged() {
let bytes = include_bytes!("value_unchanged.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("value_unchanged.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_array_input() {
let bytes = include_bytes!("array_input.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("array_input.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error)
}
@ -145,32 +159,32 @@ fn test_array_input() {
#[test]
fn test_return_array_nested_fail() {
let bytes = include_bytes!("return_array_nested_fail.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("return_array_nested_fail.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_return_array_nested_pass() {
let bytes = include_bytes!("return_array_nested_pass.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("return_array_nested_pass.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_return_array_tuple_fail() {
let bytes = include_bytes!("return_array_tuple_fail.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("return_array_tuple_fail.leo");
let program = parse_program(program_string).unwrap();
let _err = expect_compiler_error(program);
}
#[test]
fn test_return_array_tuple_pass() {
let bytes = include_bytes!("return_array_tuple_pass.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("return_array_tuple_pass.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
@ -179,16 +193,16 @@ fn test_return_array_tuple_pass() {
#[test]
fn test_return_tuple() {
let bytes = include_bytes!("return_tuple.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("return_tuple.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_return_tuple_conditional() {
let bytes = include_bytes!("return_tuple_conditional.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("return_tuple_conditional.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}

0
compiler/tests/function/multiple.leo → compiler/tests/function/multiple_returns.leo
View File

7
compiler/tests/function/multiple_returns_fail.leo Normal file
View File

@ -0,0 +1,7 @@
function main () -> i8 {
if true {
return 1i8 //ignored
}
return 2i8 //ignored
return 3i8 //returns
}

9
compiler/tests/function/multiple_returns_fail_conditional.leo Normal file
View File

@ -0,0 +1,9 @@
function main () -> u16 {
if false {
let a = 1u16;
let b = a + 1u16;
return b
} else if false {
return 0u16
}
}

0
compiler/tests/function/multiple_main.leo → compiler/tests/function/multiple_returns_main.leo
View File

105
compiler/tests/group/mod.rs
View File

@ -15,8 +15,13 @@
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use crate::{
assert_satisfied, expect_compiler_error, expect_synthesis_error, field::field_to_decimal_string,
generate_main_input, parse_program, parse_program_with_input,
assert_satisfied,
expect_compiler_error,
expect_synthesis_error,
field::field_to_decimal_string,
generate_main_input,
parse_program,
parse_program_with_input,
};
use leo_ast::{GroupCoordinate, GroupTuple, GroupValue, InputValue, Span};
@ -47,124 +52,124 @@ pub fn group_element_to_input_value(g: EdwardsAffine) -> GroupValue {
#[test]
fn test_one() {
let bytes = include_bytes!("one.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("one.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_zero() {
let bytes = include_bytes!("zero.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("zero.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_point() {
let bytes = include_bytes!("point.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("point.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_x_sign_high() {
let bytes = include_bytes!("x_sign_high.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("x_sign_high.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_x_sign_low() {
let bytes = include_bytes!("x_sign_low.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("x_sign_low.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_x_sign_inferred() {
let bytes = include_bytes!("x_sign_inferred.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("x_sign_inferred.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_y_sign_high() {
let bytes = include_bytes!("y_sign_high.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("y_sign_high.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_y_sign_low() {
let bytes = include_bytes!("y_sign_low.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("y_sign_low.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_y_sign_inferred() {
let bytes = include_bytes!("y_sign_inferred.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("y_sign_inferred.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_both_sign_high() {
let bytes = include_bytes!("both_sign_high.leo");
let program_string = include_str!("both_sign_high.leo");
let program = parse_program(bytes).unwrap();
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_both_sign_low() {
let bytes = include_bytes!("both_sign_low.leo");
let program_string = include_str!("both_sign_low.leo");
let program = parse_program(bytes).unwrap();
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_both_sign_inferred() {
let bytes = include_bytes!("both_sign_inferred.leo");
let program_string = include_str!("both_sign_inferred.leo");
let program = parse_program(bytes).unwrap();
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_point_input() {
let program_bytes = include_bytes!("point_input.leo");
let input_bytes = include_bytes!("input/point.in");
let program_string = include_str!("point_input.leo");
let input_bytes = include_str!("input/point.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program = parse_program_with_input(program_string, input_bytes).unwrap();
assert_satisfied(program);
}
#[test]
fn test_input() {
let program_bytes = include_bytes!("input.leo");
let input_bytes_pass = include_bytes!("input/valid.in");
let input_bytes_fail = include_bytes!("input/invalid.in");
let program_string = include_str!("input.leo");
let input_string_pass = include_str!("input/valid.in");
let input_string_fail = include_str!("input/invalid.in");
let program = parse_program_with_input(program_bytes, input_bytes_pass).unwrap();
let program = parse_program_with_input(program_string, input_string_pass).unwrap();
assert_satisfied(program);
let program = parse_program_with_input(program_bytes, input_bytes_fail).unwrap();
let program = parse_program_with_input(program_string, input_string_fail).unwrap();
expect_compiler_error(program);
}
@ -182,8 +187,8 @@ fn test_negate() {
let a_element = group_element_to_input_value(a);
let b_element = group_element_to_input_value(b);
let bytes = include_bytes!("negate.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("negate.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Group(a_element))),
@ -210,8 +215,8 @@ fn test_add() {
let b_element = group_element_to_input_value(b);
let c_element = group_element_to_input_value(c);
let bytes = include_bytes!("add.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("add.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Group(a_element))),
@ -239,8 +244,8 @@ fn test_sub() {
let b_element = group_element_to_input_value(b);
let c_element = group_element_to_input_value(c);
let bytes = include_bytes!("sub.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("sub.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Group(a_element))),
@ -262,8 +267,8 @@ fn test_console_assert_pass() {
let a_element = group_element_to_input_value(a);
let bytes = include_bytes!("assert_eq.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("assert_eq.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Group(a_element.clone()))),
@ -291,8 +296,8 @@ fn test_console_assert_fail() {
let a_element = group_element_to_input_value(a);
let b_element = group_element_to_input_value(b);
let bytes = include_bytes!("assert_eq.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("assert_eq.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Group(a_element))),
@ -318,8 +323,8 @@ fn test_eq() {
// test equal
let bytes = include_bytes!("eq.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("eq.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Group(a_element.clone()))),
@ -335,7 +340,7 @@ fn test_eq() {
let c = a.eq(&b);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Group(a_element))),
@ -359,8 +364,8 @@ fn test_ternary() {
let a_element = group_element_to_input_value(a);
let b_element = group_element_to_input_value(b);
let bytes = include_bytes!("ternary.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("ternary.leo");
let mut program = parse_program(program_string).unwrap();
// true -> field a
let main_input = generate_main_input(vec![
@ -374,7 +379,7 @@ fn test_ternary() {
assert_satisfied(program);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
// false -> field b
let main_input = generate_main_input(vec![

48
compiler/tests/import/mod.rs
View File

@ -34,8 +34,8 @@ pub fn set_local_dir() {
fn test_basic() {
set_local_dir();
let bytes = include_bytes!("basic.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("basic.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
@ -45,8 +45,8 @@ fn test_basic() {
fn test_multiple() {
set_local_dir();
let bytes = include_bytes!("multiple.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("multiple.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
@ -56,8 +56,8 @@ fn test_multiple() {
fn test_star() {
set_local_dir();
let bytes = include_bytes!("star.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("star.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
@ -67,8 +67,8 @@ fn test_star() {
fn test_star_fail() {
set_local_dir();
let bytes = include_bytes!("star_fail.leo");
assert!(parse_program(bytes).is_err());
let program_string = include_str!("star_fail.leo");
assert!(parse_program(program_string).is_err());
}
#[test]
@ -76,8 +76,8 @@ fn test_star_fail() {
fn test_alias() {
set_local_dir();
let bytes = include_bytes!("alias.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("alias.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
@ -88,8 +88,8 @@ fn test_alias() {
fn test_names_pass() {
set_local_dir();
let bytes = include_bytes!("names.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("names.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
@ -99,8 +99,8 @@ fn test_names_pass() {
fn test_names_fail_1() {
set_local_dir();
let bytes = include_bytes!("names_dash_a.leo");
assert!(parse_program(bytes).is_err());
let program_string = include_str!("names_dash_a.leo");
assert!(parse_program(program_string).is_err());
}
#[test]
@ -108,8 +108,8 @@ fn test_names_fail_1() {
fn test_names_fail_2() {
set_local_dir();
let bytes = include_bytes!("names_a_dash.leo");
assert!(parse_program(bytes).is_err());
let program_string = include_str!("names_a_dash.leo");
assert!(parse_program(program_string).is_err());
}
#[test]
@ -117,8 +117,8 @@ fn test_names_fail_2() {
fn test_names_fail_3() {
set_local_dir();
let bytes = include_bytes!("names_underscore.leo");
assert!(parse_program(bytes).is_err());
let program_string = include_str!("names_underscore.leo");
assert!(parse_program(program_string).is_err());
}
#[test]
@ -126,8 +126,8 @@ fn test_names_fail_3() {
fn test_names_fail_4() {
set_local_dir();
let bytes = include_bytes!("names_dollar.leo");
assert!(parse_program(bytes).is_err());
let program_string = include_str!("names_dollar.leo");
assert!(parse_program(program_string).is_err());
}
// more complex tests
@ -136,8 +136,8 @@ fn test_names_fail_4() {
fn test_many_import() {
set_local_dir();
let bytes = include_bytes!("many_import.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("many_import.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
@ -147,8 +147,8 @@ fn test_many_import() {
fn test_many_import_star() {
set_local_dir();
let bytes = include_bytes!("many_import_star.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("many_import_star.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}

24
compiler/tests/input_files/program_input/mod.rs
View File

@ -26,40 +26,40 @@ fn expect_fail(program: EdwardsTestCompiler) {
#[test]
fn test_input_pass() {
let program_bytes = include_bytes!("main.leo");
let input_bytes = include_bytes!("input/main.in");
let program_string = include_str!("main.leo");
let input_string = include_str!("input/main.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_input_fail_name() {
let program_bytes = include_bytes!("main.leo");
let input_bytes = include_bytes!("input/main_fail_name.in");
let program_string = include_str!("main.leo");
let input_string = include_str!("input/main_fail_name.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program = parse_program_with_input(program_string, input_string).unwrap();
expect_fail(program);
}
#[test]
fn test_input_fail_type() {
let program_bytes = include_bytes!("main.leo");
let input_bytes = include_bytes!("input/main_fail_type.in");
let program_string = include_str!("main.leo");
let input_string = include_str!("input/main_fail_type.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program = parse_program_with_input(program_string, input_string).unwrap();
expect_fail(program);
}
#[test]
fn test_input_multiple() {
let program_bytes = include_bytes!("main_multiple.leo");
let input_bytes = include_bytes!("input/main_multiple.in");
let program_string = include_str!("main_multiple.leo");
let input_string = include_str!("input/main_multiple.in");
let program = parse_program_with_input(program_bytes, input_bytes).unwrap();
let program = parse_program_with_input(program_string, input_string).unwrap();
assert_satisfied(program);
}

20
compiler/tests/input_files/program_input_and_program_state/mod.rs
View File

@ -18,27 +18,27 @@ use crate::{assert_satisfied, parse_input_and_state, parse_program_with_input_an
#[test]
fn test_basic() {
let input_bytes = include_bytes!("input/basic.in");
let state_bytes = include_bytes!("input/basic.state");
let input_string = include_str!("input/basic.in");
let state_string = include_str!("input/basic.state");
parse_input_and_state(input_bytes, state_bytes).unwrap();
parse_input_and_state(input_string, state_string).unwrap();
}
#[test]
fn test_full() {
let input_bytes = include_bytes!("input/token_withdraw.in");
let state_bytes = include_bytes!("input/token_withdraw.state");
let input_string = include_str!("input/token_withdraw.in");
let state_string = include_str!("input/token_withdraw.state");
parse_input_and_state(input_bytes, state_bytes).unwrap();
parse_input_and_state(input_string, state_string).unwrap();
}
#[test]
fn test_access() {
let program_bytes = include_bytes!("access.leo");
let input_bytes = include_bytes!("input/token_withdraw.in");
let state_bytes = include_bytes!("input/token_withdraw.state");
let program_string = include_str!("access.leo");
let input_string = include_str!("input/token_withdraw.in");
let state_string = include_str!("input/token_withdraw.state");
let program = parse_program_with_input_and_state(program_bytes, input_bytes, state_bytes).unwrap();
let program = parse_program_with_input_and_state(program_string, input_string, state_string).unwrap();
assert_satisfied(program);
}

32
compiler/tests/input_files/program_state/mod.rs
View File

@ -18,61 +18,61 @@ use crate::{assert_satisfied, parse_program_with_state, parse_state};
#[test]
fn test_basic() {
let bytes = include_bytes!("input/basic.state");
let state_string = include_str!("input/basic.state");
parse_state(bytes).unwrap();
parse_state(state_string).unwrap();
}
#[test]
fn test_token_withdraw() {
let bytes = include_bytes!("input/token_withdraw.state");
let state_string = include_str!("input/token_withdraw.state");
parse_state(bytes).unwrap();
parse_state(state_string).unwrap();
}
#[test]
fn test_access_state() {
let program_bytes = include_bytes!("access_state.leo");
let state_bytes = include_bytes!("input/token_withdraw.state");
let program_string = include_str!("access_state.leo");
let state_string = include_str!("input/token_withdraw.state");
let program = parse_program_with_state(program_bytes, state_bytes).unwrap();
let program = parse_program_with_state(program_string, state_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_access_all() {
let program_bytes = include_bytes!("access_all.leo");
let state_bytes = include_bytes!("input/token_withdraw.state");
let program_string = include_str!("access_all.leo");
let state_string = include_str!("input/token_withdraw.state");
let program = parse_program_with_state(program_bytes, state_bytes).unwrap();
let program = parse_program_with_state(program_string, state_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_visibility_fail() {
let state_bytes = include_bytes!("input/visibility_fail.state");
let state_string = include_str!("input/visibility_fail.state");
let is_err = parse_state(state_bytes).is_err();
let is_err = parse_state(state_string).is_err();
assert!(is_err);
}
#[test]
fn test_section_undefined() {
let state_bytes = include_bytes!("input/section_undefined.state");
let state_string = include_str!("input/section_undefined.state");
let is_err = parse_state(state_bytes).is_err();
let is_err = parse_state(state_string).is_err();
assert!(is_err);
}
#[test]
fn test_section_invalid() {
let state_bytes = include_bytes!("input/section_invalid.state");
let state_string = include_str!("input/section_invalid.state");
let is_err = parse_state(state_bytes).is_err();
let is_err = parse_state(state_string).is_err();
assert!(is_err);
}

96
compiler/tests/integers/int_macro.rs
View File

@ -28,8 +28,8 @@ macro_rules! test_int {
None => continue,
};
let bytes = include_bytes!("negate.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("negate.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
("b", Some(InputValue::Integer($integer_type, b.to_string()))),
@ -42,15 +42,15 @@ macro_rules! test_int {
}
fn test_negate_min_fail() {
let bytes = include_bytes!("negate_min.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("negate_min.leo");
let program = parse_program(program_string).unwrap();
expect_computation_error(program);
}
fn test_negate_zero() {
let bytes = include_bytes!("negate_zero.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("negate_zero.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
@ -58,29 +58,29 @@ macro_rules! test_int {
impl IntegerTester for $name {
fn test_min() {
let bytes = include_bytes!("min.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("min.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
fn test_min_fail() {
let bytes = include_bytes!("min_fail.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("min_fail.leo");
let program = parse_program(program_string).unwrap();
expect_parsing_error(program);
}
fn test_max() {
let bytes = include_bytes!("max.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("max.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
fn test_max_fail() {
let bytes = include_bytes!("max_fail.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("max_fail.leo");
let program = parse_program(program_string).unwrap();
expect_parsing_error(program);
}
@ -95,8 +95,8 @@ macro_rules! test_int {
None => continue,
};
let bytes = include_bytes!("add.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("add.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -124,8 +124,8 @@ macro_rules! test_int {
None => continue,
};
let bytes = include_bytes!("sub.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("sub.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -149,8 +149,8 @@ macro_rules! test_int {
None => continue,
};
let bytes = include_bytes!("mul.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("mul.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -176,8 +176,8 @@ macro_rules! test_int {
continue;
}
let bytes = include_bytes!("div.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("div.leo");
let mut program = parse_program(program_string).unwrap();
// expect an error when dividing by zero
if b == 0 {
@ -220,8 +220,8 @@ macro_rules! test_int {
None => continue,
};
let bytes = include_bytes!("pow.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("pow.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -242,8 +242,8 @@ macro_rules! test_int {
// test equal
let bytes = include_bytes!("eq.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("eq.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -259,7 +259,7 @@ macro_rules! test_int {
let c = a.eq(&b);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -280,8 +280,8 @@ macro_rules! test_int {
// test a != a == false
let bytes = include_bytes!("ne.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("ne.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -297,7 +297,7 @@ macro_rules! test_int {
let c = a.ne(&b);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -318,8 +318,8 @@ macro_rules! test_int {
// test equal
let bytes = include_bytes!("ge.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("ge.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -335,7 +335,7 @@ macro_rules! test_int {
let c = a.ge(&b);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -356,8 +356,8 @@ macro_rules! test_int {
// test equal
let bytes = include_bytes!("gt.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("gt.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -373,7 +373,7 @@ macro_rules! test_int {
let c = a.gt(&b);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -394,8 +394,8 @@ macro_rules! test_int {
// test equal
let bytes = include_bytes!("le.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("le.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -411,7 +411,7 @@ macro_rules! test_int {
let c = a.le(&b);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -432,8 +432,8 @@ macro_rules! test_int {
// test equal
let bytes = include_bytes!("lt.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("lt.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -449,7 +449,7 @@ macro_rules! test_int {
let c = a.lt(&b);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -468,8 +468,8 @@ macro_rules! test_int {
let a: $type_ = rand::random();
// test equal
let bytes = include_bytes!("console_assert.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("console_assert.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -487,7 +487,7 @@ macro_rules! test_int {
continue;
}
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -504,8 +504,8 @@ macro_rules! test_int {
let a: $type_ = rand::random();
let b: $type_ = rand::random();
let bytes = include_bytes!("ternary.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("ternary.leo");
let mut program = parse_program(program_string).unwrap();
// true -> field 1
let main_input = generate_main_input(vec![
@ -520,7 +520,7 @@ macro_rules! test_int {
assert_satisfied(program);
// false -> field 2
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("s", Some(InputValue::Boolean(false))),

84
compiler/tests/integers/uint_macro.rs
View File

@ -20,29 +20,29 @@ macro_rules! test_uint {
impl IntegerTester for $name {
fn test_min() {
let bytes = include_bytes!("min.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("min.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
fn test_min_fail() {
let bytes = include_bytes!("min_fail.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("min_fail.leo");
let program = parse_program(program_string).unwrap();
expect_parsing_error(program);
}
fn test_max() {
let bytes = include_bytes!("max.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("max.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
fn test_max_fail() {
let bytes = include_bytes!("max_fail.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("max_fail.leo");
let program = parse_program(program_string).unwrap();
expect_parsing_error(program);
}
@ -57,8 +57,8 @@ macro_rules! test_uint {
None => continue,
};
let bytes = include_bytes!("add.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("add.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -82,8 +82,8 @@ macro_rules! test_uint {
None => continue,
};
let bytes = include_bytes!("sub.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("sub.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -107,8 +107,8 @@ macro_rules! test_uint {
None => continue,
};
let bytes = include_bytes!("mul.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("mul.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -132,8 +132,8 @@ macro_rules! test_uint {
None => continue,
};
let bytes = include_bytes!("div.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("div.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -158,8 +158,8 @@ macro_rules! test_uint {
None => continue,
};
let bytes = include_bytes!("pow.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("pow.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -180,8 +180,8 @@ macro_rules! test_uint {
// test equal
let bytes = include_bytes!("eq.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("eq.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -197,7 +197,7 @@ macro_rules! test_uint {
let c = a.eq(&b);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -218,8 +218,8 @@ macro_rules! test_uint {
// test a != a == false
let bytes = include_bytes!("ne.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("ne.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -235,7 +235,7 @@ macro_rules! test_uint {
let c = a.ne(&b);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -256,8 +256,8 @@ macro_rules! test_uint {
// test equal
let bytes = include_bytes!("ge.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("ge.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -273,7 +273,7 @@ macro_rules! test_uint {
let c = a.ge(&b);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -294,8 +294,8 @@ macro_rules! test_uint {
// test equal
let bytes = include_bytes!("gt.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("gt.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -311,7 +311,7 @@ macro_rules! test_uint {
let c = a.gt(&b);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -332,8 +332,8 @@ macro_rules! test_uint {
// test equal
let bytes = include_bytes!("le.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("le.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -349,7 +349,7 @@ macro_rules! test_uint {
let c = a.le(&b);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -370,8 +370,8 @@ macro_rules! test_uint {
// test equal
let bytes = include_bytes!("lt.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("lt.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -387,7 +387,7 @@ macro_rules! test_uint {
let c = a.lt(&b);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -406,8 +406,8 @@ macro_rules! test_uint {
let a: $type_ = rand::random();
// test equal
let bytes = include_bytes!("console_assert.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("console_assert.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -425,7 +425,7 @@ macro_rules! test_uint {
continue;
}
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Integer($integer_type, a.to_string()))),
@ -442,8 +442,8 @@ macro_rules! test_uint {
let a: $type_ = rand::random();
let b: $type_ = rand::random();
let bytes = include_bytes!("ternary.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("ternary.leo");
let mut program = parse_program(program_string).unwrap();
// true -> field 1
let main_input = generate_main_input(vec![
@ -458,7 +458,7 @@ macro_rules! test_uint {
assert_satisfied(program);
// false -> field 2
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("s", Some(InputValue::Boolean(false))),

58
compiler/tests/mod.rs
View File

@ -21,6 +21,7 @@ pub mod address;
pub mod array;
pub mod boolean;
pub mod circuits;
pub mod compiler;
pub mod console;
pub mod core;
pub mod definition;
@ -64,94 +65,79 @@ fn new_compiler() -> EdwardsTestCompiler {
EdwardsTestCompiler::new(program_name, path, output_dir)
}
pub(crate) fn parse_program(bytes: &[u8]) -> Result<EdwardsTestCompiler, CompilerError> {
pub(crate) fn parse_program(program_string: &str) -> Result<EdwardsTestCompiler, CompilerError> {
let mut compiler = new_compiler();
let program_string = String::from_utf8_lossy(bytes);
compiler.parse_program_from_string(&program_string)?;
compiler.parse_program_from_string(program_string)?;
Ok(compiler)
}
pub(crate) fn parse_input(bytes: &[u8]) -> Result<EdwardsTestCompiler, CompilerError> {
pub(crate) fn parse_input(input_string: &str) -> Result<EdwardsTestCompiler, CompilerError> {
let mut compiler = new_compiler();
let input_string = String::from_utf8_lossy(bytes);
let path = PathBuf::new();
compiler.parse_input(&input_string, &path, EMPTY_FILE, &path)?;
compiler.parse_input(input_string, &path, EMPTY_FILE, &path)?;
Ok(compiler)
}
pub(crate) fn parse_state(bytes: &[u8]) -> Result<EdwardsTestCompiler, CompilerError> {
pub(crate) fn parse_state(state_string: &str) -> Result<EdwardsTestCompiler, CompilerError> {
let mut compiler = new_compiler();
let state_string = String::from_utf8_lossy(bytes);
let path = PathBuf::new();
compiler.parse_input(EMPTY_FILE, &path, &state_string, &path)?;
compiler.parse_input(EMPTY_FILE, &path, state_string, &path)?;
Ok(compiler)
}
pub(crate) fn parse_input_and_state(
input_bytes: &[u8],
state_bytes: &[u8],
input_string: &str,
state_string: &str,
) -> Result<EdwardsTestCompiler, CompilerError> {
let mut compiler = new_compiler();
let input_string = String::from_utf8_lossy(input_bytes);
let state_string = String::from_utf8_lossy(state_bytes);
let path = PathBuf::new();
compiler.parse_input(&input_string, &path, &state_string, &path)?;
compiler.parse_input(input_string, &path, state_string, &path)?;
Ok(compiler)
}
pub fn parse_program_with_input(
program_bytes: &[u8],
input_bytes: &[u8],
program_string: &str,
input_string: &str,
) -> Result<EdwardsTestCompiler, CompilerError> {
let mut compiler = new_compiler();
let program_string = String::from_utf8_lossy(program_bytes);
let input_string = String::from_utf8_lossy(input_bytes);
let path = PathBuf::new();
compiler.parse_input(&input_string, &path, EMPTY_FILE, &path)?;
compiler.parse_program_from_string(&program_string)?;
compiler.parse_input(input_string, &path, EMPTY_FILE, &path)?;
compiler.parse_program_from_string(program_string)?;
Ok(compiler)
}
pub fn parse_program_with_state(
program_bytes: &[u8],
state_bytes: &[u8],
program_string: &str,
state_string: &str,
) -> Result<EdwardsTestCompiler, CompilerError> {
let mut compiler = new_compiler();
let program_string = String::from_utf8_lossy(program_bytes);
let state_string = String::from_utf8_lossy(state_bytes);
let path = PathBuf::new();
compiler.parse_input(EMPTY_FILE, &path, &state_string, &path)?;
compiler.parse_program_from_string(&program_string)?;
compiler.parse_input(EMPTY_FILE, &path, state_string, &path)?;
compiler.parse_program_from_string(program_string)?;
Ok(compiler)
}
pub fn parse_program_with_input_and_state(
program_bytes: &[u8],
input_bytes: &[u8],
state_bytes: &[u8],
program_string: &str,
input_string: &str,
state_string: &str,
) -> Result<EdwardsTestCompiler, CompilerError> {
let mut compiler = new_compiler();
let program_string = String::from_utf8_lossy(program_bytes);
let input_string = String::from_utf8_lossy(input_bytes);
let state_string = String::from_utf8_lossy(state_bytes);
let path = PathBuf::new();
compiler.parse_input(&input_string, &path, &state_string, &path)?;
compiler.parse_input(input_string, &path, state_string, &path)?;
compiler.parse_program_from_string(&program_string)?;
Ok(compiler)

64
compiler/tests/mutability/mod.rs
View File

@ -19,104 +19,104 @@ use leo_ast::InputValue;
#[test]
fn test_let() {
let bytes = include_bytes!("let.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("let.leo");
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_let_mut() {
let bytes = include_bytes!("let_mut.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("let_mut.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_let_mut_nested() {
let bytes = include_bytes!("let_mut_nested.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("let_mut_nested.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_const_fail() {
let bytes = include_bytes!("const.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("const.leo");
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_const_mut_fail() {
let bytes = include_bytes!("const_mut.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("const_mut.leo");
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_array() {
let bytes = include_bytes!("array.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("array.leo");
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_array_mut() {
let bytes = include_bytes!("array_mut.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("array_mut.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_circuit() {
let bytes = include_bytes!("circuit.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("circuit.leo");
let program = parse_program(program_string).unwrap();
expect_compiler_error(program);
}
#[test]
fn test_circuit_mut() {
let bytes = include_bytes!("circuit_mut.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("circuit_mut.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_circuit_variable_mut() {
let bytes = include_bytes!("circuit_variable_mut.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("circuit_variable_mut.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_circuit_function_mut() {
let bytes = include_bytes!("circuit_function_mut.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("circuit_function_mut.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
#[test]
fn test_circuit_static_function_mut() {
let bytes = include_bytes!("circuit_static_function_mut.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("circuit_static_function_mut.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}
#[test]
fn test_function_input() {
let bytes = include_bytes!("function_input.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("function_input.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(true)))]);
@ -127,8 +127,8 @@ fn test_function_input() {
#[test]
fn test_function_input_mut() {
let bytes = include_bytes!("function_input_mut.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("function_input_mut.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(true)))]);
@ -136,3 +136,11 @@ fn test_function_input_mut() {
assert_satisfied(program);
}
#[test]
fn test_swap() {
let program_string = include_str!("swap.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}

20
compiler/tests/mutability/swap.leo Normal file
View File

@ -0,0 +1,20 @@
// Swap two elements of an array.
function swap(mut a: [u32; 2], i: u32, j: u32) -> [u32; 2] {
let t = a[i];
a[i] = a[j];
a[j] = t;
return a
}
function main() {
let mut arr: [u32; 2] = [0, 1];
let expected: [u32; 2] = [1, 0];
// Do swap.
let actual = swap(arr, 0, 1);
// Check result.
for i in 0..2 {
console.assert(expected[i] == actual[i]);
}
}

30
compiler/tests/statements/conditional/mod.rs
View File

@ -28,8 +28,8 @@ use leo_ast::InputValue;
#[test]
fn test_assert() {
let bytes = include_bytes!("assert.leo");
let mut program_1_pass = parse_program(bytes).unwrap();
let program_string = include_str!("assert.leo");
let mut program_1_pass = parse_program(program_string).unwrap();
let mut program_0_pass = program_1_pass.clone();
let mut program_2_fail = program_1_pass.clone();
@ -60,8 +60,8 @@ fn test_assert() {
#[test]
fn test_mutate() {
let bytes = include_bytes!("mutate.leo");
let mut program_1_pass = parse_program(bytes).unwrap();
let program_string = include_str!("mutate.leo");
let mut program_1_pass = parse_program(program_string).unwrap();
let mut program_0_pass = program_1_pass.clone();
// Check that an input value of 1 satisfies the constraint system
@ -83,8 +83,8 @@ fn test_mutate() {
#[test]
fn test_for_loop() {
let bytes = include_bytes!("for_loop.leo");
let mut program_true_6 = parse_program(bytes).unwrap();
let program_string = include_str!("for_loop.leo");
let mut program_true_6 = parse_program(program_string).unwrap();
let mut program_false_0 = program_true_6.clone();
// Check that an input value of true satisfies the constraint system
@ -106,8 +106,8 @@ fn test_for_loop() {
#[test]
fn test_chain() {
let bytes = include_bytes!("chain.leo");
let mut program_1_1 = parse_program(bytes).unwrap();
let program_string = include_str!("chain.leo");
let mut program_1_1 = parse_program(program_string).unwrap();
let mut program_2_2 = program_1_1.clone();
let mut program_4_3 = program_1_1.clone();
@ -147,8 +147,8 @@ fn test_chain() {
#[test]
fn test_nested() {
let bytes = include_bytes!("nested.leo");
let mut program_true_true_3 = parse_program(bytes).unwrap();
let program_string = include_str!("nested.leo");
let mut program_true_true_3 = parse_program(program_string).unwrap();
let mut program_true_false_1 = program_true_true_3.clone();
let mut program_false_false_0 = program_true_true_3.clone();
@ -205,19 +205,19 @@ fn output_zero(program: EdwardsTestCompiler) {
#[test]
fn test_multiple_returns() {
let program_bytes = include_bytes!("multiple_returns.leo");
let program_string = include_str!("multiple_returns.leo");
// Check that an input value of 1 writes 1 to the output registers
let registers_one_bytes = include_bytes!("input/registers_one.in");
let program = parse_program_with_input(program_bytes, registers_one_bytes).unwrap();
let registers_one_string = include_str!("input/registers_one.in");
let program = parse_program_with_input(program_string, registers_one_string).unwrap();
output_one(program);
// Check that an input value of 0 writes 0 to the output registers
let registers_zero_bytes = include_bytes!("input/registers_zero.in");
let program = parse_program_with_input(program_bytes, registers_zero_bytes).unwrap();
let registers_zero_string = include_str!("input/registers_zero.in");
let program = parse_program_with_input(program_string, registers_zero_string).unwrap();
output_zero(program);
}

14
compiler/tests/statements/mod.rs
View File

@ -23,8 +23,8 @@ pub mod conditional;
#[test]
fn test_ternary_basic() {
let bytes = include_bytes!("ternary_basic.leo");
let mut program = parse_program(bytes).unwrap();
let program_string = include_str!("ternary_basic.leo");
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Boolean(true))),
@ -35,7 +35,7 @@ fn test_ternary_basic() {
assert_satisfied(program);
let mut program = parse_program(bytes).unwrap();
let mut program = parse_program(program_string).unwrap();
let main_input = generate_main_input(vec![
("a", Some(InputValue::Boolean(false))),
@ -51,16 +51,16 @@ fn test_ternary_basic() {
#[test]
fn test_iteration_basic() {
let bytes = include_bytes!("iteration_basic.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("iteration_basic.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_num_returns_fail() {
let bytes = include_bytes!("num_returns_fail.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("num_returns_fail.leo");
let error = parse_program(program_string).err().unwrap();
expect_type_inference_error(error);
}

40
compiler/tests/syntax/identifiers/mod.rs
View File

@ -18,80 +18,80 @@ use crate::parse_program;
#[test]
fn test_address_name_fail() {
let bytes = include_bytes!("address_fail.leo");
let syntax_error = parse_program(bytes).is_err();
let program_string = include_str!("address_fail.leo");
let syntax_error = parse_program(program_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_console_name_fail() {
let bytes = include_bytes!("console_fail.leo");
let syntax_error = parse_program(bytes).is_err();
let program_string = include_str!("console_fail.leo");
let syntax_error = parse_program(program_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_field_name_fail() {
let bytes = include_bytes!("field_fail.leo");
let syntax_error = parse_program(bytes).is_err();
let program_string = include_str!("field_fail.leo");
let syntax_error = parse_program(program_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_group_name_fail() {
let bytes = include_bytes!("group_fail.leo");
let syntax_error = parse_program(bytes).is_err();
let program_string = include_str!("group_fail.leo");
let syntax_error = parse_program(program_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_i8_name_fail() {
let bytes = include_bytes!("i8_fail.leo");
let syntax_error = parse_program(bytes).is_err();
let program_string = include_str!("i8_fail.leo");
let syntax_error = parse_program(program_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_input_name_fail() {
let bytes = include_bytes!("input_fail.leo");
let syntax_error = parse_program(bytes).is_err();
let program_string = include_str!("input_fail.leo");
let syntax_error = parse_program(program_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_self_type_name_fail() {
let bytes = include_bytes!("self_type_fail.leo");
let syntax_error = parse_program(bytes).is_err();
let program_string = include_str!("self_type_fail.leo");
let syntax_error = parse_program(program_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_self_keyword_name_fail() {
let bytes = include_bytes!("self_keyword_fail.leo");
let syntax_error = parse_program(bytes).is_err();
let program_string = include_str!("self_keyword_fail.leo");
let syntax_error = parse_program(program_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_true_name_fail() {
let bytes = include_bytes!("true_fail.leo");
let syntax_error = parse_program(bytes).is_err();
let program_string = include_str!("true_fail.leo");
let syntax_error = parse_program(program_string).is_err();
assert!(syntax_error);
}
#[test]
fn test_u8_name_fail() {
let bytes = include_bytes!("u8_fail.leo");
let syntax_error = parse_program(bytes).is_err();
let program_string = include_str!("u8_fail.leo");
let syntax_error = parse_program(program_string).is_err();
assert!(syntax_error);
}

17
compiler/tests/syntax/mod.rs
View File

@ -25,8 +25,8 @@ pub mod identifiers;
#[test]
#[ignore]
fn test_semicolon() {
let bytes = include_bytes!("semicolon.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("semicolon.leo");
let error = parse_program(program_string).err().unwrap();
match error {
CompilerError::ParserError(ParserError::SyntaxError(_)) => {}
@ -36,8 +36,8 @@ fn test_semicolon() {
#[test]
fn test_undefined() {
let bytes = include_bytes!("undefined.leo");
let program = parse_program(bytes).unwrap();
let program_string = include_str!("undefined.leo");
let program = parse_program(program_string).unwrap();
let error = expect_compiler_error(program);
@ -63,10 +63,9 @@ fn test_undefined() {
}
#[test]
#[ignore]
fn input_syntax_error() {
let bytes = include_bytes!("input_semicolon.leo");
let error = parse_input(bytes).err().unwrap();
let input_string = include_str!("input_semicolon.leo");
let error = parse_input(input_string).err().unwrap();
// Expect an input parser error.
match error {
@ -77,8 +76,8 @@ fn input_syntax_error() {
#[test]
fn test_compare_mismatched_types() {
let bytes = include_bytes!("compare_mismatched_types.leo");
let error = parse_program(bytes).err().unwrap();
let program_string = include_str!("compare_mismatched_types.leo");
let error = parse_program(program_string).err().unwrap();
// Expect a type inference error.
match error {

48
compiler/tests/tuples/mod.rs
View File

@ -18,105 +18,105 @@ use crate::{assert_satisfied, parse_program};
#[test]
fn test_tuple_basic() {
let program_bytes = include_bytes!("basic.leo");
let program_string = include_str!("basic.leo");
let program = parse_program(program_bytes).unwrap();
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_tuple_access() {
let program_bytes = include_bytes!("access.leo");
let program_string = include_str!("access.leo");
let program = parse_program(program_bytes).unwrap();
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_tuple_typed() {
let program_bytes = include_bytes!("typed.leo");
let program_string = include_str!("typed.leo");
let program = parse_program(program_bytes).unwrap();
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_multiple() {
let program_bytes = include_bytes!("multiple.leo");
let program_string = include_str!("multiple.leo");
let program = parse_program(program_bytes).unwrap();
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_multiple_typed() {
let program_bytes = include_bytes!("multiple_typed.leo");
let program_string = include_str!("multiple_typed.leo");
let program = parse_program(program_bytes).unwrap();
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_function() {
let program_bytes = include_bytes!("function.leo");
let program_string = include_str!("function.leo");
let program = parse_program(program_bytes).unwrap();
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_function_typed() {
let program_bytes = include_bytes!("function_typed.leo");
let program_string = include_str!("function_typed.leo");
let program = parse_program(program_bytes).unwrap();
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_function_multiple() {
let progam_bytes = include_bytes!("function_multiple.leo");
let progam_string = include_str!("function_multiple.leo");
let program = parse_program(progam_bytes).unwrap();
let program = parse_program(progam_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_nested() {
let program_bytes = include_bytes!("nested.leo");
let program_string = include_str!("nested.leo");
let program = parse_program(program_bytes).unwrap();
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_nested_access() {
let program_bytes = include_bytes!("nested_access.leo");
let program_string = include_str!("nested_access.leo");
let program = parse_program(program_bytes).unwrap();
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_nested_typed() {
let program_bytes = include_bytes!("nested_typed.leo");
let program_string = include_str!("nested_typed.leo");
let program = parse_program(program_bytes).unwrap();
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
// #[test]
// fn test_input() {
// let input_bytes = include_bytes!("inputs/input.in");
// let program_bytes = include_bytes!("")
// let input_string = include_str!("inputs/input.in");
// let program_string = include_str!("")
// }

6
core/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "leo-core"
version = "1.0.6"
version = "1.0.7"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "Core package dependencies of the Leo programming language"
homepage = "https://aleo.org"
@ -19,11 +19,11 @@ edition = "2018"
[dependencies.leo-ast]
path = "../ast"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-gadgets]
path = "../gadgets"
version = "1.0.6"
version = "1.0.7"
[dependencies.snarkos-errors]
version = "1.1.3"

2
gadgets/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "leo-gadgets"
version = "1.0.6"
version = "1.0.7"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "Gadgets of the Leo programming language"
homepage = "https://aleo.org"

14
gadgets/src/signed_integer/arithmetic/mul.rs
View File

@ -37,6 +37,8 @@ use snarkos_models::{
},
};
use std::iter;
macro_rules! mul_int_impl {
($($gadget: ident)*) => ($(
/// Bitwise multiplication of two signed integer objects.
@ -77,14 +79,16 @@ macro_rules! mul_int_impl {
let mut bits = vec![false_bit; size];
// Compute double and add algorithm
let mut to_add = Vec::new();
let mut a_shifted = Vec::new();
for (i, b_bit) in b.iter().enumerate() {
// double
let mut a_shifted = vec![false_bit; i];
a_shifted.append(&mut a.clone());
a_shifted.extend(iter::repeat(false_bit).take(i));
a_shifted.extend(a.iter());
a_shifted.truncate(size);
// conditionally add
let mut to_add = Vec::with_capacity(a_shifted.len());
to_add.reserve(a_shifted.len());
for (j, a_bit) in a_shifted.iter().enumerate() {
let selected_bit = Boolean::conditionally_select(
&mut cs.ns(|| format!("select product bit {} {}", i, j)),
@ -101,7 +105,11 @@ macro_rules! mul_int_impl {
&to_add
)?;
let _carry = bits.pop();
to_add.clear();
a_shifted.clear();
}
drop(to_add);
drop(a_shifted);
// Compute the maximum value of the sum
let max_bits = <$gadget as Int>::SIZE;

2
gadgets/src/signed_integer/arithmetic/pow.rs
View File

@ -71,7 +71,7 @@ macro_rules! pow_int_impl {
result = Self::conditionally_select(
&mut cs.ns(|| format!("mul_by_self_or_result_{}", i)),
&bit,
bit,
&mul_by_self?,
&result,
)?;

2
grammar/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "leo-grammar"
version = "1.0.6"
version = "1.0.7"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "AST generated by pest from the Leo grammar rules"
homepage = "https://aleo.org"

5
grammar/src/common/range.rs
View File

@ -20,10 +20,15 @@ use pest::Span;
use pest_ast::FromPest;
use serde::Serialize;
#[derive(Clone, Debug, FromPest, PartialEq, Serialize)]
#[pest_ast(rule(Rule::range_operator))]
pub struct RangeOperator {}
#[derive(Clone, Debug, FromPest, PartialEq, Serialize)]
#[pest_ast(rule(Rule::range))]
pub struct Range<'ast> {
pub from: Option<Expression<'ast>>,
pub operator: RangeOperator,
pub to: Option<Expression<'ast>>,
#[pest_ast(outer())]
#[serde(with = "SpanDef")]

7
grammar/src/leo.pest
View File

@ -70,7 +70,8 @@ LINE_END = { ";" ~ NEWLINE* }
mutable = { "mut " }
// Declared in common/range.rs
range = { expression? ~ ".." ~ expression? }
range_operator = { ".." }
range = { expression? ~ range_operator ~ expression? }
// Declared in common/range_or_expression.rs
range_or_expression = { range | expression }
@ -443,8 +444,8 @@ input_tuple = _{ "(" ~ NEWLINE* ~ (input ~ ("," ~ NEWLINE* ~ input)* ~ ","?)? ~
// Declared in imports/import.rs
import = { "import " ~ package ~ LINE_END}
package_name = @{ ((ASCII_ALPHA_LOWER | ASCII_DIGIT) ~ ( "-" ~ (ASCII_ALPHA_LOWER | ASCII_DIGIT))*)+ }
// Declared in imports/package_name.rs
package_name = @{ (ASCII_ALPHA_LOWER | ASCII_DIGIT)+ ~ ( "-" ~ (ASCII_ALPHA_LOWER | ASCII_DIGIT)+)* }
// Declared in imports/package.rs
package = { package_name ~ "." ~ package_access }

10
imports/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "leo-imports"
version = "1.0.6"
version = "1.0.7"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "Import parser for Leo program package dependencies"
homepage = "https://aleo.org"
@ -19,11 +19,15 @@ edition = "2018"
[dependencies.leo-ast]
path = "../ast"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-grammar]
path = "../grammar"
version = "1.0.6"
version = "1.0.7"
[dependencies.indexmap]
version = "1.6.1"
features = [ "serde-1" ]
[dependencies.thiserror]
version = "1.0"

10
imports/src/parser/import_parser.rs
View File

@ -17,10 +17,8 @@
use crate::errors::ImportParserError;
use leo_ast::{Package, Program};
use std::{
collections::{HashMap, HashSet},
env::current_dir,
};
use indexmap::{IndexMap, IndexSet};
use std::env::current_dir;
/// Stores imported packages.
///
@ -28,8 +26,8 @@ use std::{
/// directory, foreign in the imports directory, or part of the core package list.
#[derive(Clone, Default)]
pub struct ImportParser {
imports: HashMap<String, Program>,
core_packages: HashSet<Package>,
imports: IndexMap<String, Program>,
core_packages: IndexSet<Package>,
}
impl ImportParser {

2
input/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "leo-input"
version = "1.0.6"
version = "1.0.7"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "Input parser of the Leo programming language"
homepage = "https://aleo.org"

2
leo/leo-version
View File

@ -1 +1 @@
v1.0.6
v1.0.7

2
linter/Cargo.toml
View File

@ -2,7 +2,7 @@ dependencies = { }
[package]
name = "leo-linter"
version = "1.0.6"
version = "1.0.7"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "Linter of the Leo programming language"
homepage = "https://aleo.org"

2
package/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "leo-package"
version = "1.0.6"
version = "1.0.7"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "Package parser of the Leo programming language"
homepage = "https://aleo.org"

10
state/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "leo-state"
version = "1.0.6"
version = "1.0.7"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "State parser of the Leo programming language"
homepage = "https://aleo.org"
@ -19,11 +19,11 @@ edition = "2018"
[dependencies.leo-input]
path = "../input"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-ast]
path = "../ast"
version = "1.0.6"
version = "1.0.7"
[dependencies.snarkos-algorithms]
version = "1.1.3"
@ -52,6 +52,10 @@ default-features = false
[dependencies.snarkos-utilities]
version = "1.1.3"
[dependencies.indexmap]
version = "1.6.1"
features = [ "serde-1" ]
[dependencies.rand]
version = "0.7"

4
state/src/utilities/input_value.rs
View File

@ -17,13 +17,13 @@
use crate::InputValueError;
use leo_ast::{InputValue, Parameter};
use std::collections::HashMap;
use indexmap::IndexMap;
/// Returns the input parameter with the given name.
/// If a parameter with the given name does not exist, then an error is returned.
pub fn find_input(
name: String,
parameters: &HashMap<Parameter, Option<InputValue>>,
parameters: &IndexMap<Parameter, Option<InputValue>>,
) -> Result<InputValue, InputValueError> {
let matched_parameter = parameters
.iter()

16
symbol-table/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "leo-symbol-table"
version = "1.0.6"
version = "1.0.7"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "Stores user-defined variables during type resolution"
homepage = "https://aleo.org"
@ -12,26 +12,30 @@ keywords = [
"programming-language",
"zero-knowledge"
]
categories = [ "cryptography::croptocurrencies", "web-programming" ]
categories = [ "cryptography::cryptocurrencies", "web-programming" ]
include = [ "Cargo.toml", "src", "README.md", "LICENSE.md" ]
license = "GPL-3.0"
edition = "2018"
[dependencies.leo-ast]
path = "../ast"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-core]
path = "../core"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-grammar]
path = "../grammar"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-imports]
path = "../imports"
version = "1.0.6"
version = "1.0.7"
[dependencies.indexmap]
version = "1.6.1"
features = [ "serde-1" ]
[dependencies.serde]
version = "1.0"

21
symbol-table/src/symbol_table.rs
View File

@ -19,7 +19,7 @@ use leo_ast::{Circuit, Function, Identifier, ImportStatement, ImportSymbol, Inpu
use leo_core::CorePackageList;
use leo_imports::ImportParser;
use std::collections::{HashMap, HashSet};
use indexmap::{IndexMap, IndexSet};
pub const INPUT_VARIABLE_NAME: &str = "input";
pub const RECORD_VARIABLE_NAME: &str = "record";
@ -35,13 +35,13 @@ pub const STATE_LEAF_VARIABLE_NAME: &str = "state_leaf";
#[derive(Clone, Default)]
pub struct SymbolTable {
/// Maps name -> parameter type.
names: HashMap<String, UserDefinedType>,
names: IndexMap<String, UserDefinedType>,
/// Maps circuit name -> circuit type.
circuits: HashMap<String, CircuitType>,
circuits: IndexMap<String, CircuitType>,
/// Maps function name -> function type.
functions: HashMap<String, FunctionType>,
functions: IndexMap<String, FunctionType>,
/// The parent of this symbol table.
parent: Option<Box<SymbolTable>>,
@ -214,7 +214,7 @@ impl SymbolTable {
/// If a circuit name has no duplicates, then it is inserted into the symbol table.
/// Types defined later in the program cannot have the same name.
///
pub fn check_circuit_names(&mut self, circuits: &HashMap<Identifier, Circuit>) -> Result<(), SymbolTableError> {
pub fn check_circuit_names(&mut self, circuits: &IndexMap<Identifier, Circuit>) -> Result<(), SymbolTableError> {
// Iterate over circuit names and definitions.
for (identifier, circuit) in circuits.iter() {
// Attempt to insert the circuit name into the symbol table.
@ -230,7 +230,7 @@ impl SymbolTable {
/// If a function name has no duplicates, then it is inserted into the symbol table.
/// Types defined later in the program cannot have the same name.
///
pub fn check_function_names(&mut self, functions: &HashMap<Identifier, Function>) -> Result<(), SymbolTableError> {
pub fn check_function_names(&mut self, functions: &IndexMap<Identifier, Function>) -> Result<(), SymbolTableError> {
// Iterate over function names and definitions.
for (identifier, function) in functions.iter() {
// Attempt to insert the function name into the symbol table.
@ -326,7 +326,7 @@ impl SymbolTable {
// Import all symbols from an imported file for now.
// Keep track of which import files have already been checked.
let mut checked = HashSet::new();
let mut checked = IndexSet::new();
// Iterate over each imported symbol.
for (name, symbol) in imported_symbols.symbols {
@ -416,7 +416,7 @@ impl SymbolTable {
/// symbol table. Variables defined later in the program can lookup the definition
/// and refer to its expected types
///
pub fn check_types_circuits(&mut self, circuits: &HashMap<Identifier, Circuit>) -> Result<(), SymbolTableError> {
pub fn check_types_circuits(&mut self, circuits: &IndexMap<Identifier, Circuit>) -> Result<(), SymbolTableError> {
// Iterate over circuit names and definitions.
for circuit in circuits.values() {
// Get the identifier of the circuit.
@ -439,7 +439,10 @@ impl SymbolTable {
/// symbol table. Variables defined later in the program can lookup the definition
/// and refer to its expected types
///
pub fn check_types_functions(&mut self, functions: &HashMap<Identifier, Function>) -> Result<(), SymbolTableError> {
pub fn check_types_functions(
&mut self,
functions: &IndexMap<Identifier, Function>,
) -> Result<(), SymbolTableError> {
// Iterate over function names and definitions.
for function in functions.values() {
// Get the identifier of the function.

8
symbol-table/src/types/circuits/circuit.rs
View File

@ -17,11 +17,9 @@
use crate::{types::circuits::CircuitVariableType, FunctionType, SymbolTable, Type, TypeError};
use leo_ast::{Circuit, CircuitMember, Identifier, InputValue, Parameter, Span};
use indexmap::IndexMap;
use serde::{Deserialize, Serialize};
use std::{
collections::HashMap,
hash::{Hash, Hasher},
};
use std::hash::{Hash, Hasher};
/// Stores circuit definition details.
///
@ -133,7 +131,7 @@ impl CircuitType {
pub fn from_input_section(
table: &SymbolTable,
name: String,
section: HashMap<Parameter, Option<InputValue>>,
section: IndexMap<Parameter, Option<InputValue>>,
) -> Result<Self, TypeError> {
// Create a new `CircuitVariableType` for each section pair.
let mut variables = Vec::new();

27
symbol-table/src/types/functions/function.rs
View File

@ -120,16 +120,6 @@ impl FunctionType {
Ok(())
}
///
/// Returns the number of input variables to the function.
/// The `self` and `mut self` keywords are not counted as input variables.
///
pub fn num_inputs(&self) -> usize {
self.inputs
.iter()
.fold(0, |acc, function_input| acc + function_input.count())
}
///
/// Returns `true` if the input `self` or `mut self` is present.
/// Returns `false` otherwise.
@ -139,13 +129,18 @@ impl FunctionType {
}
///
/// Returns a vector of [&FunctionInputType] removing `self` and `mut self` inputs.
/// Returns an iterator of [&FunctionInputType] removing `self` and `mut self` inputs.
///
pub fn filter_self_inputs(&self) -> Vec<&FunctionInputType> {
self.inputs
.iter()
.filter(|input| !input.is_self())
.collect::<Vec<&FunctionInputType>>()
pub fn filter_self_inputs(&self) -> impl Iterator<Item = &FunctionInputType> {
self.inputs.iter().filter(|input| !input.is_self())
}
///
/// Returns the number of input variables to the function.
/// The `self` and `mut self` keywords are not counted as input variables.
///
pub fn num_inputs(&self) -> usize {
self.filter_self_inputs().count()
}
}

9
symbol-table/src/types/functions/function_input.rs
View File

@ -77,15 +77,6 @@ impl FunctionInputType {
}
}
///
/// Returns `0` if the function input is a `self` or `mut self` keyword which does not have to
/// provided in a call to the function.
/// Returns `1` if a variable must be provided in a call to the function.
///
pub fn count(&self) -> usize {
if self.is_self() { 0 } else { 1 }
}
///
/// Return a new `FunctionInputType` from a given `FunctionInput`.
///

7
symbol-table/tests/mod.rs
View File

@ -34,15 +34,12 @@ impl TestSymbolTable {
///
/// Returns a Leo syntax tree given a Leo program.
///
pub fn new(bytes: &[u8]) -> Self {
// Get file string from bytes.
let file_string = String::from_utf8_lossy(bytes);
pub fn new(program_string: &str) -> Self {
// Get test file path.
let file_path = PathBuf::from(TEST_PROGRAM_PATH);
// Get parser syntax tree.
let grammar = Grammar::new(&file_path, &*file_string).unwrap();
let grammar = Grammar::new(&file_path, program_string).unwrap();
// Get Leo syntax tree.
let ast = Ast::new(TEST_PROGRAM_PATH, &grammar);

16
symbol-table/tests/symbol_table/mod.rs
View File

@ -25,8 +25,8 @@ use crate::TestSymbolTable;
///
#[test]
fn test_duplicate_circuit() {
let program_bytes = include_bytes!("duplicate_circuit.leo");
let resolver = TestSymbolTable::new(program_bytes);
let program_string = include_str!("duplicate_circuit.leo");
let resolver = TestSymbolTable::new(program_string);
resolver.expect_pass_one_error();
}
@ -40,8 +40,8 @@ fn test_duplicate_circuit() {
///
#[test]
fn test_duplicate_function() {
let program_bytes = include_bytes!("duplicate_function.leo");
let resolver = TestSymbolTable::new(program_bytes);
let program_string = include_str!("duplicate_function.leo");
let resolver = TestSymbolTable::new(program_string);
resolver.expect_pass_one_error();
}
@ -54,8 +54,8 @@ fn test_duplicate_function() {
///
#[test]
fn test_self_not_available() {
let program_bytes = include_bytes!("self_not_available.leo");
let resolver = TestSymbolTable::new(program_bytes);
let program_string = include_str!("self_not_available.leo");
let resolver = TestSymbolTable::new(program_string);
resolver.expect_pass_two_error();
}
@ -68,8 +68,8 @@ fn test_self_not_available() {
///
#[test]
fn test_undefined_circuit() {
let program_bytes = include_bytes!("undefined_circuit.leo");
let resolver = TestSymbolTable::new(program_bytes);
let program_string = include_str!("undefined_circuit.leo");
let resolver = TestSymbolTable::new(program_string);
resolver.expect_pass_two_error();
}

16
type-inference/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "leo-type-inference"
version = "1.0.6"
version = "1.0.7"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "Checks that a program is correct using type inference"
homepage = "https://aleo.org"
@ -12,26 +12,30 @@ keywords = [
"programming-language",
"zero-knowledge"
]
categories = [ "cryptography::croptocurrencies", "web-programming" ]
categories = [ "cryptography::cryptocurrencies", "web-programming" ]
include = [ "Cargo.toml", "src", "README.md", "LICENSE.md" ]
license = "GPL-3.0"
edition = "2018"
[dependencies.leo-ast]
path = "../ast"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-imports]
path = "../imports"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-grammar]
path = "../grammar"
version = "1.0.6"
version = "1.0.7"
[dependencies.leo-symbol-table]
path = "../symbol-table"
version = "1.0.6"
version = "1.0.7"
[dependencies.indexmap]
version = "1.6.1"
features = [ "serde-1" ]
[dependencies.serde_json]
version = "1.0"

8
type-inference/src/objects/frame.rs
View File

@ -830,7 +830,7 @@ impl Frame {
// Check that the type is an array.
match array_type {
Type::Array(element_type) => Ok(Type::Array(element_type)),
Type::Array(element_type) => Ok(*element_type),
type_ => Err(FrameError::invalid_spread(type_, span)),
}
}
@ -1078,8 +1078,6 @@ impl Frame {
return Err(FrameError::static_call_invalid(&identifier));
}
if is_static && function_type.contains_self() {}
// Return the function type.
Ok(function_type.to_owned())
}
@ -1112,10 +1110,8 @@ impl Frame {
}
// Filter out `self` and `mut self` keywords.
let expected_inputs = function_type.filter_self_inputs();
// Assert function inputs are correct types.
for (expected_input, actual_input) in expected_inputs.iter().zip(inputs) {
for (expected_input, actual_input) in function_type.filter_self_inputs().zip(inputs) {
// Parse expected input type.
let expected_type = expected_input.type_();

7
type-inference/src/objects/variable_table.rs
View File

@ -16,11 +16,12 @@
use crate::VariableTableError;
use leo_symbol_table::{FunctionInputType, Type};
use std::collections::HashMap;
use indexmap::IndexMap;
/// Mapping of variable names to types
#[derive(Clone)]
pub struct VariableTable(pub HashMap<String, Type>);
pub struct VariableTable(pub IndexMap<String, Type>);
impl VariableTable {
///
@ -67,6 +68,6 @@ impl VariableTable {
impl Default for VariableTable {
fn default() -> Self {
Self(HashMap::new())
Self(IndexMap::new())
}
}

12
type-inference/tests/arrays/mod.rs
View File

@ -18,27 +18,27 @@ use crate::TestTypeInference;
#[test]
fn test_empty_array() {
let bytes = include_bytes!("empty_array.leo");
let program_string = include_str!("empty_array.leo");
let check = TestTypeInference::new(bytes);
let check = TestTypeInference::new(program_string);
check.expect_error();
}
#[test]
fn test_invalid_array_access() {
let bytes = include_bytes!("invalid_array_access.leo");
let program_string = include_str!("invalid_array_access.leo");
let check = TestTypeInference::new(bytes);
let check = TestTypeInference::new(program_string);
check.expect_error();
}
#[test]
fn test_invalid_spread() {
let bytes = include_bytes!("invalid_spread.leo");
let program_string = include_str!("invalid_spread.leo");
let check = TestTypeInference::new(bytes);
let check = TestTypeInference::new(program_string);
check.expect_error();
}

4
type-inference/tests/circuits/mod.rs
View File

@ -18,8 +18,8 @@ use crate::TestTypeInference;
#[test]
fn test_invalid_circuit() {
let bytes = include_bytes!("invalid_circuit.leo");
let check = TestTypeInference::new(bytes);
let program_string = include_str!("invalid_circuit.leo");
let check = TestTypeInference::new(program_string);
check.expect_error();
}

4
type-inference/tests/functions/mod.rs
View File

@ -18,8 +18,8 @@ use crate::TestTypeInference;
#[test]
fn test_invalid_function() {
let bytes = include_bytes!("invalid_function.leo");
let check = TestTypeInference::new(bytes);
let program_string = include_str!("invalid_function.leo");
let check = TestTypeInference::new(program_string);
check.expect_error();
}

11
type-inference/tests/mod.rs
View File

@ -38,15 +38,12 @@ pub struct TestTypeInference {
}
impl TestTypeInference {
pub fn new(bytes: &[u8]) -> Self {
// Get file string from bytes.
let file_string = String::from_utf8_lossy(bytes);
pub fn new(program_string: &str) -> Self {
// Get test file path.
let file_path = PathBuf::from(TEST_PROGRAM_PATH);
// Get parser syntax tree.
let ast = Grammar::new(&file_path, &*file_string).unwrap();
let ast = Grammar::new(&file_path, program_string).unwrap();
// Get typed syntax tree.
let typed = Ast::new(TEST_PROGRAM_NAME, &ast);
@ -76,9 +73,9 @@ impl TestTypeInference {
#[test]
fn test_new() {
let bytes = include_bytes!("empty.leo");
let program_string = include_str!("empty.leo");
let type_inference = TestTypeInference::new(bytes);
let type_inference = TestTypeInference::new(program_string);
type_inference.check()
}

4
type-inference/tests/tuples/mod.rs
View File

@ -18,8 +18,8 @@ use crate::TestTypeInference;
#[test]
fn test_invalid_tuple_access() {
let bytes = include_bytes!("invalid_tuple_access.leo");
let check = TestTypeInference::new(bytes);
let program_string = include_str!("invalid_tuple_access.leo");
let check = TestTypeInference::new(program_string);
check.expect_error();
}

16
type-inference/tests/variables/mod.rs
View File

@ -18,32 +18,32 @@ use crate::TestTypeInference;
#[test]
fn test_duplicate_variable() {
let bytes = include_bytes!("duplicate_variable.leo");
let check = TestTypeInference::new(bytes);
let program_string = include_str!("duplicate_variable.leo");
let check = TestTypeInference::new(program_string);
check.expect_error();
}
#[test]
fn test_duplicate_variable_multi() {
let bytes = include_bytes!("duplicate_variable_multi.leo");
let check = TestTypeInference::new(bytes);
let program_string = include_str!("duplicate_variable_multi.leo");
let check = TestTypeInference::new(program_string);
check.expect_error();
}
#[test]
fn test_not_enough_values() {
let bytes = include_bytes!("not_enough_values.leo");
let check = TestTypeInference::new(bytes);
let program_string = include_str!("not_enough_values.leo");
let check = TestTypeInference::new(program_string);
check.expect_error();
}
#[test]
fn test_too_many_values() {
let bytes = include_bytes!("too_many_values.leo");
let check = TestTypeInference::new(bytes);
let program_string = include_str!("too_many_values.leo");
let check = TestTypeInference::new(program_string);
check.expect_error();
}