diff --git a/Cargo.lock b/Cargo.lock index c4235b2c913..9a099308613 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -357,14 +357,14 @@ dependencies = [ [[package]] name = "async-lsp" -version = "0.0.4" -source = "git+https://github.com/oxalica/async-lsp?rev=09dbcc11046f7a188a80137f8d36484d86c78c78#09dbcc11046f7a188a80137f8d36484d86c78c78" +version = "0.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72bd600f2652d2cccb0a33ab4f92d163ab3930844c8b0ad3713a5ae3285eeb4e" dependencies = [ - "either", "futures", "lsp-types 0.94.0", "pin-project-lite", - "rustix 0.37.23", + "rustix 0.38.4", "serde", "serde_json", "thiserror", @@ -372,7 +372,7 @@ dependencies = [ "tower-layer", "tower-service", "tracing", - "windows-sys 0.48.0", + "waitpid-any", ] [[package]] @@ -1979,6 +1979,7 @@ version = "0.9.0" dependencies = [ "acvm", "base64", + "fm", "iter-extended", "noirc_abi", "noirc_driver", @@ -2001,7 +2002,6 @@ dependencies = [ "assert_fs", "async-lsp", "build-data", - "cfg-if", "clap", "color-eyre", "const_format", @@ -2010,6 +2010,7 @@ dependencies = [ "hex", "iter-extended", "nargo", + "nargo_toml", "noir_lsp", "noirc_abi", "noirc_driver", @@ -2023,8 +2024,22 @@ dependencies = [ "termcolor", "thiserror", "tokio", + "tokio-util", "toml", "tower", +] + +[[package]] +name = "nargo_toml" +version = "0.9.0" +dependencies = [ + "dirs", + "fm", + "nargo", + "noirc_frontend", + "serde", + "thiserror", + "toml", "url", ] @@ -3368,6 +3383,7 @@ checksum = "806fe8c2c87eccc8b3267cbae29ed3ab2d0bd37fca70ab622e46aaa9375ddb7d" dependencies = [ "bytes", "futures-core", + "futures-io", "futures-sink", "pin-project-lite", "tokio", @@ -3582,6 +3598,16 @@ dependencies = [ "libc", ] +[[package]] +name = "waitpid-any" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "54f8c3c56044fc359f905b72879576a15d49c46d085ed6266a98826716f14033" +dependencies = [ + "rustix 0.38.4", + "windows-sys 0.48.0", +] + [[package]] name = "walkdir" version = "2.3.3" diff --git a/Cargo.toml b/Cargo.toml index 0b05d783e11..b7dc03f87ac 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,6 +7,7 @@ members = [ "crates/noirc_driver", "crates/nargo", "crates/nargo_cli", + "crates/nargo_toml", "crates/fm", "crates/arena", "crates/noirc_abi", @@ -30,6 +31,7 @@ fm = { path = "crates/fm" } iter-extended = { path = "crates/iter-extended" } nargo = { path = "crates/nargo" } nargo_cli = { path = "crates/nargo_cli" } +nargo_toml = { path = "crates/nargo_toml" } noir_lsp = { path = "crates/lsp" } noirc_abi = { path = "crates/noirc_abi" } noirc_driver = { path = "crates/noirc_driver" } @@ -55,6 +57,3 @@ url = "2.2.0" wasm-bindgen = { version = "=0.2.86", features = ["serde-serialize"] } wasm-bindgen-test = "0.3.33" base64 = "0.21.2" - -[patch.crates-io] -async-lsp = { git = "https://github.com/oxalica/async-lsp", rev = "09dbcc11046f7a188a80137f8d36484d86c78c78" } diff --git a/crates/lsp/Cargo.toml b/crates/lsp/Cargo.toml index 2611abd67dc..3cde18bfba9 100644 --- a/crates/lsp/Cargo.toml +++ b/crates/lsp/Cargo.toml @@ -19,7 +19,7 @@ noirc_frontend.workspace = true serde_json.workspace = true toml.workspace = true tower.workspace = true -async-lsp = { version = "0.0.4", default-features = false, features = ["omni-trait"] } +async-lsp = { version = "0.0.5", default-features = false, features = ["omni-trait"] } [dev-dependencies] tokio = { version = "1.0", features = ["macros"] } diff --git a/crates/nargo/Cargo.toml b/crates/nargo/Cargo.toml index 3039268281c..32ca04ad34f 100644 --- a/crates/nargo/Cargo.toml +++ b/crates/nargo/Cargo.toml @@ -12,6 +12,7 @@ rustc_version = "0.4.0" [dependencies] acvm.workspace = true +fm.workspace = true noirc_abi.workspace = true noirc_driver.workspace = true noirc_frontend.workspace = true diff --git a/crates/nargo/src/lib.rs b/crates/nargo/src/lib.rs index fda02cf98c2..44261307886 100644 --- a/crates/nargo/src/lib.rs +++ b/crates/nargo/src/lib.rs @@ -14,4 +14,43 @@ pub mod ops; pub mod package; pub mod workspace; +use std::collections::BTreeMap; + +use fm::FileManager; +use noirc_driver::{add_dep, prepare_crate}; +use noirc_frontend::{ + graph::{CrateGraph, CrateId, CrateName}, + hir::Context, +}; +use package::{Dependency, Package}; + pub use self::errors::NargoError; + +pub fn prepare_dependencies( + context: &mut Context, + parent_crate: CrateId, + dependencies: &BTreeMap, +) { + for (dep_name, dep) in dependencies.iter() { + match dep { + Dependency::Remote { package } | Dependency::Local { package } => { + let crate_id = prepare_crate(context, &package.entry_path); + add_dep(context, parent_crate, crate_id, dep_name.clone()); + prepare_dependencies(context, crate_id, &package.dependencies); + } + } + } +} + +pub fn prepare_package(package: &Package) -> (Context, CrateId) { + // TODO: FileManager continues to leak into various crates + let fm = FileManager::new(&package.root_dir); + let graph = CrateGraph::default(); + let mut context = Context::new(fm, graph); + + let crate_id = prepare_crate(&mut context, &package.entry_path); + + prepare_dependencies(&mut context, crate_id, &package.dependencies); + + (context, crate_id) +} diff --git a/crates/nargo/src/package.rs b/crates/nargo/src/package.rs index 6c690fe9caf..16f65d329ba 100644 --- a/crates/nargo/src/package.rs +++ b/crates/nargo/src/package.rs @@ -8,6 +8,7 @@ use crate::constants::{PROVER_INPUT_FILE, VERIFIER_INPUT_FILE}; pub enum PackageType { Library, Binary, + Contract, } impl Display for PackageType { @@ -15,6 +16,7 @@ impl Display for PackageType { match self { Self::Library => write!(f, "lib"), Self::Binary => write!(f, "bin"), + Self::Contract => write!(f, "contract"), } } } @@ -64,6 +66,10 @@ impl Package { self.package_type == PackageType::Binary } + pub fn is_contract(&self) -> bool { + self.package_type == PackageType::Contract + } + pub fn is_library(&self) -> bool { self.package_type == PackageType::Library } diff --git a/crates/nargo_cli/Cargo.toml b/crates/nargo_cli/Cargo.toml index a1c15997ef5..fd052e9dc95 100644 --- a/crates/nargo_cli/Cargo.toml +++ b/crates/nargo_cli/Cargo.toml @@ -18,34 +18,34 @@ build-data = "0.1.3" toml.workspace = true [dependencies] -cfg-if.workspace = true clap.workspace = true dirs.workspace = true -url.workspace = true iter-extended.workspace = true nargo.workspace = true +nargo_toml.workspace = true noir_lsp.workspace = true noirc_driver.workspace = true noirc_frontend.workspace = true noirc_abi.workspace = true noirc_errors.workspace = true acvm.workspace = true -fm.workspace = true toml.workspace = true serde.workspace = true serde_json.workspace = true thiserror.workspace = true tower.workspace = true -async-lsp = { version = "0.0.4", default-features = false, features = [ +async-lsp = { version = "0.0.5", default-features = false, features = [ "client-monitor", "stdio", "tracing", + "tokio" ] } const_format = "0.2.30" hex = "0.4.2" termcolor = "1.1.2" color-eyre = "0.6.2" tokio = { version = "1.0", features = ["io-std"] } +tokio-util = { version = "0.7.8", features = ["compat"] } # Backends acvm-backend-barretenberg = { version = "0.10.0", default-features = false } @@ -55,11 +55,11 @@ tempdir = "0.3.7" assert_cmd = "2.0.8" assert_fs = "1.0.10" predicates = "2.1.5" +fm.workspace = true [features] default = ["plonk_bn254"] # The plonk backend can only use bn254, so we do not specify the field plonk_bn254 = ["acvm-backend-barretenberg/native"] plonk_bn254_wasm = ["acvm-backend-barretenberg/wasm"] -flat_witness = ["acvm-backend-barretenberg/native"] diff --git a/crates/nargo_cli/src/backends.rs b/crates/nargo_cli/src/backends.rs index 39fbc2f24d2..bbec5c99006 100644 --- a/crates/nargo_cli/src/backends.rs +++ b/crates/nargo_cli/src/backends.rs @@ -1,6 +1,6 @@ pub(crate) use acvm_backend_barretenberg::Barretenberg as ConcreteBackend; -#[cfg(not(any(feature = "plonk_bn254", feature = "plonk_bn254_wasm", feature = "flat_witness")))] +#[cfg(not(any(feature = "plonk_bn254", feature = "plonk_bn254_wasm")))] compile_error!("please specify a backend to compile with"); #[cfg(all(feature = "plonk_bn254", feature = "plonk_bn254_wasm"))] diff --git a/crates/nargo_cli/src/cli/check_cmd.rs b/crates/nargo_cli/src/cli/check_cmd.rs index 1d292fbf188..44d4dca1a49 100644 --- a/crates/nargo_cli/src/cli/check_cmd.rs +++ b/crates/nargo_cli/src/cli/check_cmd.rs @@ -1,13 +1,9 @@ -use crate::{ - errors::{CliError, CompileError}, - find_package_manifest, - manifest::resolve_workspace_from_toml, - prepare_package, -}; +use crate::errors::{CliError, CompileError}; use acvm::Backend; use clap::Args; use iter_extended::btree_map; -use nargo::package::Package; +use nargo::{package::Package, prepare_package}; +use nargo_toml::{find_package_manifest, resolve_workspace_from_toml}; use noirc_abi::{AbiParameter, AbiType, MAIN_RETURN_NAME}; use noirc_driver::{check_crate, compute_function_signature, CompileOptions}; use noirc_frontend::{ @@ -116,11 +112,10 @@ fn create_input_toml_template( mod tests { use std::path::PathBuf; + use nargo_toml::{find_package_manifest, resolve_workspace_from_toml}; use noirc_abi::{AbiParameter, AbiType, AbiVisibility, Sign}; use noirc_driver::CompileOptions; - use crate::{find_package_manifest, manifest::resolve_workspace_from_toml}; - use super::create_input_toml_template; const TEST_DATA_DIR: &str = "tests/target_tests_data"; diff --git a/crates/nargo_cli/src/cli/codegen_verifier_cmd.rs b/crates/nargo_cli/src/cli/codegen_verifier_cmd.rs index 297b54fddb1..bc7e1c80c0f 100644 --- a/crates/nargo_cli/src/cli/codegen_verifier_cmd.rs +++ b/crates/nargo_cli/src/cli/codegen_verifier_cmd.rs @@ -14,13 +14,13 @@ use super::{ }, }; use crate::errors::CliError; -use crate::{find_package_manifest, manifest::resolve_workspace_from_toml}; use acvm::Backend; use clap::Args; use nargo::{ ops::{codegen_verifier, preprocess_program}, package::Package, }; +use nargo_toml::{find_package_manifest, resolve_workspace_from_toml}; use noirc_driver::CompileOptions; use noirc_frontend::graph::CrateName; diff --git a/crates/nargo_cli/src/cli/compile_cmd.rs b/crates/nargo_cli/src/cli/compile_cmd.rs index 651992f0fd9..4430b9bb851 100644 --- a/crates/nargo_cli/src/cli/compile_cmd.rs +++ b/crates/nargo_cli/src/cli/compile_cmd.rs @@ -3,7 +3,9 @@ use acvm::{acir::circuit::Circuit, Backend}; use iter_extended::try_vecmap; use iter_extended::vecmap; use nargo::package::Package; +use nargo::prepare_package; use nargo::{artifacts::contract::PreprocessedContract, NargoError}; +use nargo_toml::{find_package_manifest, resolve_workspace_from_toml}; use noirc_driver::{ compile_contracts, compile_main, CompileOptions, CompiledProgram, ErrorsAndWarnings, Warnings, }; @@ -15,8 +17,6 @@ use clap::Args; use nargo::ops::{preprocess_contract_function, preprocess_program}; use crate::errors::{CliError, CompileError}; -use crate::manifest::resolve_workspace_from_toml; -use crate::{find_package_manifest, prepare_package}; use super::fs::{ common_reference_string::{ @@ -37,10 +37,6 @@ pub(crate) struct CompileCommand { #[arg(long)] include_keys: bool, - /// Compile each contract function used within the program - #[arg(short, long)] - contracts: bool, - /// The name of the package to compile #[clap(long)] package: Option, @@ -60,10 +56,10 @@ pub(crate) fn run( let mut common_reference_string = read_cached_common_reference_string(); - // If contracts is set we're compiling every function in a 'contract' rather than just 'main'. - if args.contracts { - for package in &workspace { - let (mut context, crate_id) = prepare_package(package); + for package in &workspace { + let (mut context, crate_id) = prepare_package(package); + // If `contract` package type, we're compiling every function in a 'contract' rather than just 'main'. + if package.is_contract() { let result = compile_contracts(&mut context, crate_id, &args.compile_options); let contracts = report_errors(result, &context, args.compile_options.deny_warnings)?; @@ -105,9 +101,7 @@ pub(crate) fn run( &circuit_dir, ); } - } - } else { - for package in &workspace { + } else { let (_, program) = compile_package(backend, package, &args.compile_options)?; common_reference_string = diff --git a/crates/nargo_cli/src/cli/execute_cmd.rs b/crates/nargo_cli/src/cli/execute_cmd.rs index fa6b13a5134..1f0095fed5a 100644 --- a/crates/nargo_cli/src/cli/execute_cmd.rs +++ b/crates/nargo_cli/src/cli/execute_cmd.rs @@ -5,6 +5,7 @@ use clap::Args; use nargo::constants::PROVER_INPUT_FILE; use nargo::package::Package; use nargo::NargoError; +use nargo_toml::{find_package_manifest, resolve_workspace_from_toml}; use noirc_abi::input_parser::{Format, InputValue}; use noirc_abi::{Abi, InputMap}; use noirc_driver::{CompileOptions, CompiledProgram}; @@ -16,8 +17,6 @@ use super::compile_cmd::compile_package; use super::fs::{inputs::read_inputs_from_file, witness::save_witness_to_dir}; use super::NargoConfig; use crate::errors::CliError; -use crate::find_package_manifest; -use crate::manifest::resolve_workspace_from_toml; /// Executes a circuit to calculate its return value #[derive(Debug, Clone, Args)] diff --git a/crates/nargo_cli/src/cli/fs/witness.rs b/crates/nargo_cli/src/cli/fs/witness.rs index edfb1aa63d6..1a2cf88f4a1 100644 --- a/crates/nargo_cli/src/cli/fs/witness.rs +++ b/crates/nargo_cli/src/cli/fs/witness.rs @@ -14,30 +14,9 @@ pub(crate) fn save_witness_to_dir>( create_named_dir(witness_dir.as_ref(), "witness"); let witness_path = witness_dir.as_ref().join(witness_name).with_extension(WITNESS_EXT); - let buf: Vec = serialize_witness_map(witnesses)?; + let buf: Vec = witnesses.try_into()?; write_to_file(buf.as_slice(), &witness_path); Ok(witness_path) } - -#[cfg(not(feature = "flat_witness"))] -fn serialize_witness_map(witnesses: WitnessMap) -> Result, FilesystemError> { - let buf: Vec = witnesses.try_into()?; - Ok(buf) -} - -#[cfg(feature = "flat_witness")] -fn serialize_witness_map(witnesses: WitnessMap) -> Result, FilesystemError> { - let mut buf: Vec = Vec::new(); - let mut counter = 1; - for (index, value) in witnesses { - while counter < index.witness_index() { - buf.extend(vec![0; 32]); - counter += 1; - } - buf.extend_from_slice(&value.to_be_bytes()); - counter += 1; - } - Ok(buf) -} diff --git a/crates/nargo_cli/src/cli/info_cmd.rs b/crates/nargo_cli/src/cli/info_cmd.rs index bfa0e7985db..213f494d7a9 100644 --- a/crates/nargo_cli/src/cli/info_cmd.rs +++ b/crates/nargo_cli/src/cli/info_cmd.rs @@ -1,13 +1,11 @@ use acvm::Backend; use clap::Args; use nargo::package::Package; +use nargo_toml::{find_package_manifest, resolve_workspace_from_toml}; use noirc_driver::CompileOptions; use noirc_frontend::graph::CrateName; -use crate::{ - cli::compile_cmd::compile_package, errors::CliError, find_package_manifest, - manifest::resolve_workspace_from_toml, -}; +use crate::{cli::compile_cmd::compile_package, errors::CliError}; use super::NargoConfig; diff --git a/crates/nargo_cli/src/cli/init_cmd.rs b/crates/nargo_cli/src/cli/init_cmd.rs index edfb9c3410c..d6ad172ce26 100644 --- a/crates/nargo_cli/src/cli/init_cmd.rs +++ b/crates/nargo_cli/src/cli/init_cmd.rs @@ -16,12 +16,16 @@ pub(crate) struct InitCommand { name: Option, /// Use a library template - #[arg(long, conflicts_with = "bin")] + #[arg(long, conflicts_with = "bin", conflicts_with = "contract")] pub(crate) lib: bool, /// Use a binary template [default] - #[arg(long, conflicts_with = "lib")] + #[arg(long, conflicts_with = "lib", conflicts_with = "contract")] pub(crate) bin: bool, + + /// Use a contract template + #[arg(long, conflicts_with = "lib", conflicts_with = "bin")] + pub(crate) contract: bool, } const BIN_EXAMPLE: &str = r#"fn main(x : Field, y : pub Field) { @@ -37,6 +41,13 @@ fn test_main() { } "#; +const CONTRACT_EXAMPLE: &str = r#"contract Main { + internal fn double(x: Field) -> pub Field { x * 2 } + fn triple(x: Field) -> pub Field { x * 3 } + fn quadruple(x: Field) -> pub Field { double(double(x)) } +} +"#; + const LIB_EXAMPLE: &str = r#"fn my_util(x : Field, y : Field) -> bool { x != y } @@ -60,7 +71,13 @@ pub(crate) fn run( .name .unwrap_or_else(|| config.program_dir.file_name().unwrap().to_str().unwrap().to_owned()); - let package_type = if args.lib { PackageType::Library } else { PackageType::Binary }; + let package_type = if args.lib { + PackageType::Library + } else if args.contract { + PackageType::Contract + } else { + PackageType::Binary + }; initialize_project(config.program_dir, &package_name, package_type); Ok(()) } @@ -88,6 +105,9 @@ compiler_version = "{CARGO_PKG_VERSION}" // This uses the `match` syntax instead of `if` so we get a compile error when we add new package types (which likely need new template files) match package_type { PackageType::Binary => write_to_file(BIN_EXAMPLE.as_bytes(), &src_dir.join("main.nr")), + PackageType::Contract => { + write_to_file(CONTRACT_EXAMPLE.as_bytes(), &src_dir.join("main.nr")) + } PackageType::Library => write_to_file(LIB_EXAMPLE.as_bytes(), &src_dir.join("lib.nr")), }; println!("Project successfully created! It is located at {}", package_dir.display()); diff --git a/crates/nargo_cli/src/cli/lsp_cmd.rs b/crates/nargo_cli/src/cli/lsp_cmd.rs index 789ba6fe88d..ac15f4f8a9f 100644 --- a/crates/nargo_cli/src/cli/lsp_cmd.rs +++ b/crates/nargo_cli/src/cli/lsp_cmd.rs @@ -5,7 +5,6 @@ use async_lsp::{ }; use clap::Args; use noir_lsp::NargoLspService; -use tokio::io::BufReader; use tower::ServiceBuilder; use super::NargoConfig; @@ -30,7 +29,7 @@ pub(crate) fn run( let runtime = Builder::new_current_thread().enable_all().build().unwrap(); runtime.block_on(async { - let (server, _) = async_lsp::Frontend::new_server(|client| { + let (server, _) = async_lsp::MainLoop::new_server(|client| { let router = NargoLspService::new(&client); ServiceBuilder::new() @@ -42,7 +41,7 @@ pub(crate) fn run( .service(router) }); - // Prefer truely asynchronous piped stdin/stdout without blocking tasks. + // Prefer truly asynchronous piped stdin/stdout without blocking tasks. #[cfg(unix)] let (stdin, stdout) = ( async_lsp::stdio::PipeStdin::lock_tokio().unwrap(), @@ -50,10 +49,11 @@ pub(crate) fn run( ); // Fallback to spawn blocking read/write otherwise. #[cfg(not(unix))] - let (stdin, stdout) = (tokio::io::stdin(), tokio::io::stdout()); - - let stdin = BufReader::new(stdin); + let (stdin, stdout) = ( + tokio_util::compat::TokioAsyncReadCompatExt::compat(tokio::io::stdin()), + tokio_util::compat::TokioAsyncWriteCompatExt::compat_write(tokio::io::stdout()), + ); - server.run(stdin, stdout).await.map_err(CliError::LspError) + server.run_buffered(stdin, stdout).await.map_err(CliError::LspError) }) } diff --git a/crates/nargo_cli/src/cli/mod.rs b/crates/nargo_cli/src/cli/mod.rs index 3ec23d8ed58..817bfabf57d 100644 --- a/crates/nargo_cli/src/cli/mod.rs +++ b/crates/nargo_cli/src/cli/mod.rs @@ -1,11 +1,10 @@ use clap::{Args, Parser, Subcommand}; use const_format::formatcp; +use nargo_toml::find_package_root; use std::path::PathBuf; use color_eyre::eyre; -use crate::find_package_root; - mod fs; mod check_cmd; @@ -61,7 +60,7 @@ enum NargoCommand { Lsp(lsp_cmd::LspCommand), } -pub fn start_cli() -> eyre::Result<()> { +pub(crate) fn start_cli() -> eyre::Result<()> { let NargoCli { command, mut config } = NargoCli::parse(); // Search through parent directories to find package root if necessary. diff --git a/crates/nargo_cli/src/cli/new_cmd.rs b/crates/nargo_cli/src/cli/new_cmd.rs index 85e2522a5a5..dbdeddef712 100644 --- a/crates/nargo_cli/src/cli/new_cmd.rs +++ b/crates/nargo_cli/src/cli/new_cmd.rs @@ -17,12 +17,16 @@ pub(crate) struct NewCommand { name: Option, /// Use a library template - #[arg(long, conflicts_with = "bin")] + #[arg(long, conflicts_with = "bin", conflicts_with = "contract")] pub(crate) lib: bool, /// Use a binary template [default] - #[arg(long, conflicts_with = "lib")] + #[arg(long, conflicts_with = "lib", conflicts_with = "contract")] pub(crate) bin: bool, + + /// Use a contract template + #[arg(long, conflicts_with = "lib", conflicts_with = "bin")] + pub(crate) contract: bool, } pub(crate) fn run( @@ -39,7 +43,13 @@ pub(crate) fn run( let package_name = args.name.unwrap_or_else(|| args.path.file_name().unwrap().to_str().unwrap().to_owned()); - let package_type = if args.lib { PackageType::Library } else { PackageType::Binary }; + let package_type = if args.lib { + PackageType::Library + } else if args.contract { + PackageType::Contract + } else { + PackageType::Binary + }; initialize_project(package_dir, &package_name, package_type); Ok(()) } diff --git a/crates/nargo_cli/src/cli/prove_cmd.rs b/crates/nargo_cli/src/cli/prove_cmd.rs index d7eaf2d1405..018e150f89f 100644 --- a/crates/nargo_cli/src/cli/prove_cmd.rs +++ b/crates/nargo_cli/src/cli/prove_cmd.rs @@ -6,6 +6,7 @@ use nargo::artifacts::program::PreprocessedProgram; use nargo::constants::{PROVER_INPUT_FILE, VERIFIER_INPUT_FILE}; use nargo::ops::{preprocess_program, prove_execution, verify_proof}; use nargo::package::Package; +use nargo_toml::{find_package_manifest, resolve_workspace_from_toml}; use noirc_abi::input_parser::Format; use noirc_driver::CompileOptions; use noirc_frontend::graph::CrateName; @@ -21,8 +22,6 @@ use super::fs::{ proof::save_proof_to_dir, }; use super::NargoConfig; -use crate::find_package_manifest; -use crate::manifest::resolve_workspace_from_toml; use crate::{cli::execute_cmd::execute_program, errors::CliError}; /// Create proof for this program. The proof is returned as a hex encoded string. diff --git a/crates/nargo_cli/src/cli/test_cmd.rs b/crates/nargo_cli/src/cli/test_cmd.rs index e52e3e5aa8d..ecbee5b4668 100644 --- a/crates/nargo_cli/src/cli/test_cmd.rs +++ b/crates/nargo_cli/src/cli/test_cmd.rs @@ -2,15 +2,13 @@ use std::io::Write; use acvm::{acir::native_types::WitnessMap, Backend}; use clap::Args; -use nargo::{ops::execute_circuit, package::Package}; +use nargo::{ops::execute_circuit, package::Package, prepare_package}; +use nargo_toml::{find_package_manifest, resolve_workspace_from_toml}; use noirc_driver::{compile_no_check, CompileOptions}; use noirc_frontend::{graph::CrateName, hir::Context, node_interner::FuncId}; use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor}; -use crate::{ - cli::check_cmd::check_crate_and_report_errors, errors::CliError, find_package_manifest, - manifest::resolve_workspace_from_toml, prepare_package, -}; +use crate::{cli::check_cmd::check_crate_and_report_errors, errors::CliError}; use super::{compile_cmd::optimize_circuit, NargoConfig}; diff --git a/crates/nargo_cli/src/cli/verify_cmd.rs b/crates/nargo_cli/src/cli/verify_cmd.rs index cceaf997af7..5af28b4e25b 100644 --- a/crates/nargo_cli/src/cli/verify_cmd.rs +++ b/crates/nargo_cli/src/cli/verify_cmd.rs @@ -12,14 +12,13 @@ use super::{ }, }; use crate::errors::CliError; -use crate::find_package_manifest; -use crate::manifest::resolve_workspace_from_toml; use acvm::Backend; use clap::Args; use nargo::constants::{PROOF_EXT, VERIFIER_INPUT_FILE}; use nargo::ops::{preprocess_program, verify_proof}; use nargo::{artifacts::program::PreprocessedProgram, package::Package}; +use nargo_toml::{find_package_manifest, resolve_workspace_from_toml}; use noirc_abi::input_parser::Format; use noirc_driver::CompileOptions; use noirc_frontend::graph::CrateName; diff --git a/crates/nargo_cli/src/errors.rs b/crates/nargo_cli/src/errors.rs index ee7ea12f761..d801a56d3f5 100644 --- a/crates/nargo_cli/src/errors.rs +++ b/crates/nargo_cli/src/errors.rs @@ -3,7 +3,8 @@ use acvm::{ SmartContract, }; use hex::FromHexError; -use nargo::{package::PackageType, NargoError}; +use nargo::NargoError; +use nargo_toml::ManifestError; use noirc_abi::errors::{AbiError, InputParserError}; use noirc_errors::reporter::ReportedErrors; use noirc_frontend::graph::CrateName; @@ -96,58 +97,3 @@ impl From for CompileError { Self::ReportedErrors(errors) } } - -/// Errors covering situations where a package is either missing or malformed. -#[derive(Debug, Error)] -pub(crate) enum ManifestError { - /// Package doesn't have a manifest file - #[error("cannot find a Nargo.toml in {}", .0.display())] - MissingFile(PathBuf), - - #[error("Cannot read file {0} - does it exist?")] - ReadFailed(PathBuf), - - #[error("Nargo.toml is missing a parent directory")] - MissingParent, - - #[error("Missing `type` field in {0}")] - MissingPackageType(PathBuf), - - #[error("Cannot use `{1}` for `type` field in {0}")] - InvalidPackageType(PathBuf, String), - - /// Package manifest is unreadable. - #[error("Nargo.toml is badly formed, could not parse.\n\n {0}")] - MalformedFile(#[from] toml::de::Error), - - #[error("Unxpected workspace definition found in {0}")] - UnexpectedWorkspace(PathBuf), - - #[error("Cannot find file {entry} which was specified as the `entry` field in {toml}")] - MissingEntryFile { toml: PathBuf, entry: PathBuf }, - - #[error( - r#"Cannot find file {entry} which is defaulted due to specifying `type = "{package_type}"` in {toml}"# - )] - MissingDefaultEntryFile { toml: PathBuf, entry: PathBuf, package_type: PackageType }, - - /// Invalid character `-` in package name - #[error("invalid character `-` in package name")] - InvalidPackageName, - - /// Encountered error while downloading git repository. - #[error("{0}")] - GitError(String), - - #[error("Selected package `{0}` was not found")] - MissingSelectedPackage(CrateName), - - #[error("Default package was not found. Does {0} exist in your workspace?")] - MissingDefaultPackage(PathBuf), - - #[error("Package `{0}` has type `bin` but you cannot depend on binary packages")] - BinaryDependency(CrateName), - - #[error("Missing `name` field in {toml}")] - MissingNameField { toml: PathBuf }, -} diff --git a/crates/nargo_cli/src/lib.rs b/crates/nargo_cli/src/lib.rs deleted file mode 100644 index d90ce39259d..00000000000 --- a/crates/nargo_cli/src/lib.rs +++ /dev/null @@ -1,105 +0,0 @@ -#![forbid(unsafe_code)] -#![warn(unused_extern_crates)] -#![warn(unreachable_pub)] -#![warn(clippy::semicolon_if_nothing_returned)] - -//! Nargo is the package manager for Noir -//! This name was used because it sounds like `cargo` and -//! Noir Package Manager abbreviated is npm, which is already taken. - -use fm::FileManager; -use nargo::package::{Dependency, Package}; -use noirc_driver::{add_dep, prepare_crate}; -use noirc_frontend::{ - graph::{CrateGraph, CrateId, CrateName}, - hir::Context, -}; -use std::{ - collections::BTreeMap, - fs::ReadDir, - path::{Path, PathBuf}, -}; - -use errors::ManifestError; - -mod backends; -pub mod cli; -mod errors; -mod git; -mod manifest; - -fn nargo_crates() -> PathBuf { - dirs::home_dir().unwrap().join("nargo") -} - -/// Returns the path of the root directory of the package containing `current_path`. -/// -/// Returns a `CliError` if no parent directories of `current_path` contain a manifest file. -fn find_package_root(current_path: &Path) -> Result { - let manifest_path = find_package_manifest(current_path)?; - - let package_root = - manifest_path.parent().expect("infallible: manifest file path can't be root directory"); - - Ok(package_root.to_path_buf()) -} - -/// Returns the path of the manifest file (`Nargo.toml`) of the package containing `current_path`. -/// -/// Returns a `CliError` if no parent directories of `current_path` contain a manifest file. -fn find_package_manifest(current_path: &Path) -> Result { - current_path - .ancestors() - .find_map(|dir| find_file(dir, "Nargo", "toml")) - .ok_or_else(|| ManifestError::MissingFile(current_path.to_path_buf())) -} - -// Looks for file named `file_name` in path -fn find_file>(path: P, file_name: &str, extension: &str) -> Option { - let entries = list_files_and_folders_in(path)?; - let file_name = format!("{file_name}.{extension}"); - - find_artifact(entries, &file_name) -} - -// There is no distinction between files and folders -fn find_artifact(entries: ReadDir, artifact_name: &str) -> Option { - let entry = entries - .into_iter() - .flatten() - .find(|entry| entry.file_name().to_str() == Some(artifact_name))?; - - Some(entry.path()) -} - -fn list_files_and_folders_in>(path: P) -> Option { - std::fs::read_dir(path).ok() -} - -fn prepare_dependencies( - context: &mut Context, - parent_crate: CrateId, - dependencies: &BTreeMap, -) { - for (dep_name, dep) in dependencies.iter() { - match dep { - Dependency::Remote { package } | Dependency::Local { package } => { - let crate_id = prepare_crate(context, &package.entry_path); - add_dep(context, parent_crate, crate_id, dep_name.clone()); - prepare_dependencies(context, crate_id, &package.dependencies); - } - } - } -} - -fn prepare_package(package: &Package) -> (Context, CrateId) { - let fm = FileManager::new(&package.root_dir); - let graph = CrateGraph::default(); - let mut context = Context::new(fm, graph); - - let crate_id = prepare_crate(&mut context, &package.entry_path); - - prepare_dependencies(&mut context, crate_id, &package.dependencies); - - (context, crate_id) -} diff --git a/crates/nargo_cli/src/main.rs b/crates/nargo_cli/src/main.rs index a79c43dad48..734dbdca2e7 100644 --- a/crates/nargo_cli/src/main.rs +++ b/crates/nargo_cli/src/main.rs @@ -1,7 +1,17 @@ #![forbid(unsafe_code)] +#![warn(unused_extern_crates)] +#![warn(unreachable_pub)] +#![warn(clippy::semicolon_if_nothing_returned)] + +//! Nargo is the package manager for Noir +//! This name was used because it sounds like `cargo` and +//! Noir Package Manager abbreviated is npm, which is already taken. + +mod backends; +mod cli; +mod errors; use color_eyre::{config::HookBuilder, eyre}; -use nargo_cli::cli::start_cli; const PANIC_MESSAGE: &str = "This is a bug. We may have already fixed this in newer versions of Nargo so try searching for similar issues at https://github.com/noir-lang/noir/issues/.\nIf there isn't an open issue for this bug, consider opening one at https://github.com/noir-lang/noir/issues/new?labels=bug&template=bug_report.yml"; @@ -11,5 +21,5 @@ fn main() -> eyre::Result<()> { HookBuilder::default().display_env_section(false).panic_section(PANIC_MESSAGE).into_hooks(); panic_hook.install(); - start_cli() + cli::start_cli() } diff --git a/crates/nargo_cli/tests/compile_success/numeric_generics/src/main.nr b/crates/nargo_cli/tests/compile_success/numeric_generics/src/main.nr index f1efafc19fd..1e03a382fed 100644 --- a/crates/nargo_cli/tests/compile_success/numeric_generics/src/main.nr +++ b/crates/nargo_cli/tests/compile_success/numeric_generics/src/main.nr @@ -23,7 +23,7 @@ struct MyStruct { } impl MyStruct { - fn insert(mut self: Self, index: comptime Field, elem: Field) -> Self { + fn insert(mut self: Self, index: Field, elem: Field) -> Self { // Regression test for numeric generics on impls assert(index as u64 < S as u64); diff --git a/crates/nargo_cli/tests/execution_success/array_len/src/main.nr b/crates/nargo_cli/tests/execution_success/array_len/src/main.nr index 65c2295cefb..ac9811e021e 100644 --- a/crates/nargo_cli/tests/execution_success/array_len/src/main.nr +++ b/crates/nargo_cli/tests/execution_success/array_len/src/main.nr @@ -18,7 +18,7 @@ fn main(x: Field, len3: [u8; 3], len4: [Field; 4]) { assert(add_lens(len3, len4) == 7); assert(nested_call(len4) == 5); - // std::array::len returns a comptime value + // std::array::len returns a compile-time known value assert(len4[len3.len()] == 4); // Regression for #1023, ensure .len still works after calling to_le_bytes on a witness. diff --git a/crates/nargo_cli/tests/execution_success/bit_shifts_comptime/src/main.nr b/crates/nargo_cli/tests/execution_success/bit_shifts_comptime/src/main.nr index c1c6890febb..87e8479300e 100644 --- a/crates/nargo_cli/tests/execution_success/bit_shifts_comptime/src/main.nr +++ b/crates/nargo_cli/tests/execution_success/bit_shifts_comptime/src/main.nr @@ -2,12 +2,12 @@ fn main(x: u64) { let two: u64 = 2; let three: u64 = 3; - // comptime shifts on comptime values + // shifts on constant values assert(two << 2 == 8); assert((two << 3) / 8 == two); assert((three >> 1) == 1); - // comptime shifts on runtime values + // shifts on runtime values assert(x << 1 == 128); assert(x >> 2 == 16); } diff --git a/crates/nargo_cli/tests/execution_success/bit_shifts_runtime/src/main.nr b/crates/nargo_cli/tests/execution_success/bit_shifts_runtime/src/main.nr index 271a1ecb880..f4d9c3916a6 100644 --- a/crates/nargo_cli/tests/execution_success/bit_shifts_runtime/src/main.nr +++ b/crates/nargo_cli/tests/execution_success/bit_shifts_runtime/src/main.nr @@ -1,9 +1,9 @@ fn main(x: u64, y: u64) { - // runtime shifts on comptime values + // runtime shifts on compile-time known values assert(64 << y == 128); assert(64 >> y == 32); // runtime shifts on runtime values assert(x << y == 128); assert(x >> y == 32); -} \ No newline at end of file +} diff --git a/crates/nargo_cli/tests/execution_success/comptime_array_access/Nargo.toml b/crates/nargo_cli/tests/execution_success/comptime_array_access/Nargo.toml deleted file mode 100644 index 794702bbeaa..00000000000 --- a/crates/nargo_cli/tests/execution_success/comptime_array_access/Nargo.toml +++ /dev/null @@ -1,7 +0,0 @@ -[package] -name = "comptime_array_access" -type = "bin" -authors = [""] -compiler_version = "0.1" - -[dependencies] diff --git a/crates/nargo_cli/tests/execution_success/comptime_array_access/Prover.toml b/crates/nargo_cli/tests/execution_success/comptime_array_access/Prover.toml deleted file mode 100644 index ec8d8e34856..00000000000 --- a/crates/nargo_cli/tests/execution_success/comptime_array_access/Prover.toml +++ /dev/null @@ -1 +0,0 @@ -a = [1, 2, 3] diff --git a/crates/nargo_cli/tests/execution_success/comptime_array_access/src/main.nr b/crates/nargo_cli/tests/execution_success/comptime_array_access/src/main.nr deleted file mode 100644 index 04f08bb70c5..00000000000 --- a/crates/nargo_cli/tests/execution_success/comptime_array_access/src/main.nr +++ /dev/null @@ -1,17 +0,0 @@ -fn main(a: [Field; 3]) { - let i = 1; - - // Using a comptime variable as a parameter should not make it non-comptime - let ii = foo(i); - let elem1 = a[i]; - - // Nor should using it in an expression with a non-comptime variable. - let two = i + ii; - assert(i == ii); - - let elem2 = a[i]; - assert(elem1 == elem2); - assert(two == 2); -} - -fn foo(x: Field) -> Field { x } diff --git a/crates/nargo_cli/tests/execution_success/comptime_array_access/target/comptime_array_access.json b/crates/nargo_cli/tests/execution_success/comptime_array_access/target/comptime_array_access.json deleted file mode 100644 index 5e17d6d504e..00000000000 --- a/crates/nargo_cli/tests/execution_success/comptime_array_access/target/comptime_array_access.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"a","type":{"kind":"array","length":3,"type":{"kind":"field"}},"visibility":"private"}],"param_witnesses":{"a":[1,2,3]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/81UUQrDIAzN2ur+dpbEaI1/u8pk9v5H2EodhDK2jyr0gTzNR/KSJ7kCgIUNpvJY+fI+g3qDiq+4V2acvS/RFWJ6oEtZAvqQZyGhIOHphLmIl5hyipjIc6ElJF5ww6Ry4UGMSt8vzXgM1FKz1mvUfao8qNjHC9uhJ9jV2c/x9iXWtHgPk0yHvBbaff5efdv2HqFKeeqZ/ltgK15vGI6d+QQAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/execution_success/comptime_array_access/target/witness.tr b/crates/nargo_cli/tests/execution_success/comptime_array_access/target/witness.tr deleted file mode 100644 index 5e9a938686f..00000000000 Binary files a/crates/nargo_cli/tests/execution_success/comptime_array_access/target/witness.tr and /dev/null differ diff --git a/crates/nargo_cli/tests/execution_success/contracts/Nargo.toml b/crates/nargo_cli/tests/execution_success/contracts/Nargo.toml index cca289aa4fd..4abcfab93d3 100644 --- a/crates/nargo_cli/tests/execution_success/contracts/Nargo.toml +++ b/crates/nargo_cli/tests/execution_success/contracts/Nargo.toml @@ -1,6 +1,6 @@ [package] name = "contracts" -type = "bin" +type = "contract" authors = [""] compiler_version = "0.1" diff --git a/crates/nargo_cli/tests/execution_success/distinct_keyword/src/main.nr b/crates/nargo_cli/tests/execution_success/distinct_keyword/src/main.nr index 5bf3f7e0975..d84be844d8e 100644 --- a/crates/nargo_cli/tests/execution_success/distinct_keyword/src/main.nr +++ b/crates/nargo_cli/tests/execution_success/distinct_keyword/src/main.nr @@ -1,4 +1,4 @@ // Example that uses the distinct keyword -fn main(x: pub Field) -> distinct pub [Field; 3] { - [x+1, x, x] +fn main(x: pub Field) -> distinct pub [Field;2] { + [x+1, x] } diff --git a/crates/nargo_cli/tests/execution_success/distinct_keyword/target/distinct_keyword.json b/crates/nargo_cli/tests/execution_success/distinct_keyword/target/distinct_keyword.json index 77dc3d9fe1c..ad8ebce2475 100644 --- a/crates/nargo_cli/tests/execution_success/distinct_keyword/target/distinct_keyword.json +++ b/crates/nargo_cli/tests/execution_success/distinct_keyword/target/distinct_keyword.json @@ -1 +1 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"public"}],"param_witnesses":{"x":[1]},"return_type":{"kind":"array","length":3,"type":{"kind":"field"}},"return_witnesses":[2,1,3]},"bytecode":"H4sIAAAAAAAA/9VPOQ7AIAzj6IMSkkCy9StFhf8/oQtISB3LUi8+Bss+nHPBvTGzczB8A/qliyAzt5IaEl6QrKoAS82KiqJyJyVqylqsWgFDpoZdjPooCxt3/eVz3LcL5l+/cFx0GP4Bi8kGuhwCAAA=","proving_key":null,"verification_key":null} \ No newline at end of file +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"public"}],"param_witnesses":{"x":[1]},"return_type":{"kind":"array","length":2,"type":{"kind":"field"}},"return_witnesses":[3,4]},"bytecode":"H4sIAAAAAAAA/9WRQQ6AIAwEEfU/LW2lvfkVifj/JxgSTEg8Cgf3srftTnd1zs3uLV99rw7fhFOTRbAx5xgyEh4QLKkAS9oUFUXlDEqUlTVasgiGTBkvMbpqmO/YaySz78g89+sFf9l5GcA8Nf6wl9+WWzcyyYCuDAMAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/execution_success/distinct_keyword/target/witness.tr b/crates/nargo_cli/tests/execution_success/distinct_keyword/target/witness.tr index 57b9214a4e1..d79dfba9359 100644 Binary files a/crates/nargo_cli/tests/execution_success/distinct_keyword/target/witness.tr and b/crates/nargo_cli/tests/execution_success/distinct_keyword/target/witness.tr differ diff --git a/crates/nargo_cli/tests/execution_success/eddsa/Nargo.toml b/crates/nargo_cli/tests/execution_success/eddsa/Nargo.toml new file mode 100644 index 00000000000..039da3a7074 --- /dev/null +++ b/crates/nargo_cli/tests/execution_success/eddsa/Nargo.toml @@ -0,0 +1,8 @@ +[package] +name = "eddsa" +description = "Eddsa verification" +type = "bin" +authors = [""] +compiler_version = "0.3.2" + +[dependencies] diff --git a/crates/nargo_cli/tests/execution_success/eddsa/Prover.toml b/crates/nargo_cli/tests/execution_success/eddsa/Prover.toml new file mode 100644 index 00000000000..53555202ca6 --- /dev/null +++ b/crates/nargo_cli/tests/execution_success/eddsa/Prover.toml @@ -0,0 +1,3 @@ +_priv_key_a = 123 +_priv_key_b = 456 +msg = 789 diff --git a/crates/nargo_cli/tests/execution_success/eddsa/src/main.nr b/crates/nargo_cli/tests/execution_success/eddsa/src/main.nr new file mode 100644 index 00000000000..8de38011aaf --- /dev/null +++ b/crates/nargo_cli/tests/execution_success/eddsa/src/main.nr @@ -0,0 +1,55 @@ +use dep::std::compat; +use dep::std::ec::consts::te::baby_jubjub; +use dep::std::hash; +use dep::std::eddsa::eddsa_poseidon_verify; +use dep::std; + +fn main(msg: pub Field, _priv_key_a: Field, _priv_key_b: Field) { + // Skip this test for non-bn254 backends + if compat::is_bn254() { + let bjj = baby_jubjub(); + + let pub_key_a = bjj.curve.mul(_priv_key_a, bjj.curve.gen); + // let pub_key_b = bjj.curve.mul(_priv_key_b, bjj.curve.gen); + + // Manually computed as fields can't use modulo. Importantantly the commitment is within + // the subgroup order. Note that choice of hash is flexible for this step. + // let r_a = hash::pedersen([_priv_key_a, msg])[0] % bjj.suborder; // modulus computed manually + let r_a = 1414770703199880747815475415092878800081323795074043628810774576767372531818; + // let r_b = hash::pedersen([_priv_key_b, msg])[0] % bjj.suborder; // modulus computed manually + let r_b = 571799555715456644614141527517766533395606396271089506978608487688924659618; + + let r8_a = bjj.curve.mul(r_a, bjj.base8); + let r8_b = bjj.curve.mul(r_b, bjj.base8); + + // let h_a: [Field; 6] = hash::poseidon::bn254::hash_5([ + // r8_a.x, + // r8_a.y, + // pub_key_a.x, + // pub_key_a.y, + // msg, + // ]); + + // let h_b: [Field; 6] = hash::poseidon::bn254::hash_5([ + // r8_b.x, + // r8_b.y, + // pub_key_b.x, + // pub_key_b.y, + // msg, + // ]); + + // let s_a = (r_a + _priv_key_a * h_a) % bjj.suborder; // modulus computed manually + let s_a = 30333430637424319196043722294837632681219980330991241982145549329256671548; + // let s_b = (r_b + _priv_key_b * h_b) % bjj.suborder; // modulus computed manually + let s_b = 1646085314320208098241070054368798527940102577261034947654839408482102287019; + + // User A verifies their signature over the message + assert(eddsa_poseidon_verify(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg)); + + // User B's signature over the message can't be used with user A's pub key + assert(!eddsa_poseidon_verify(pub_key_a.x, pub_key_a.y, s_b, r8_b.x, r8_b.y, msg)); + + // User A's signature over the message can't be used with another message + assert(!eddsa_poseidon_verify(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg + 1)); + } +} \ No newline at end of file diff --git a/crates/nargo_cli/tests/execution_success/eddsa/target/eddsa.json b/crates/nargo_cli/tests/execution_success/eddsa/target/eddsa.json new file mode 100644 index 00000000000..88b9e5212be --- /dev/null +++ b/crates/nargo_cli/tests/execution_success/eddsa/target/eddsa.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"msg","type":{"kind":"field"},"visibility":"public"},{"name":"_priv_key_a","type":{"kind":"field"},"visibility":"private"},{"name":"_priv_key_b","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"_priv_key_a":[2],"_priv_key_b":[3],"msg":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/execution_success/eddsa/target/witness.tr b/crates/nargo_cli/tests/execution_success/eddsa/target/witness.tr new file mode 100644 index 00000000000..7349cf05cee Binary files /dev/null and b/crates/nargo_cli/tests/execution_success/eddsa/target/witness.tr differ diff --git a/crates/nargo_cli/tests/execution_success/generics/src/main.nr b/crates/nargo_cli/tests/execution_success/generics/src/main.nr index bfde9d3c957..4c87bc685f1 100644 --- a/crates/nargo_cli/tests/execution_success/generics/src/main.nr +++ b/crates/nargo_cli/tests/execution_success/generics/src/main.nr @@ -54,4 +54,18 @@ fn main(x: Field, y: Field) { let two = y; let nested_generics: Bar> = Bar { one, two, other: Bar { one, two, other: 0 } }; assert(nested_generics.other.other == bar1.get_other()); + + let _ = regression_2055([1, 2, 3]); +} + +fn regression_2055(bytes: [u8; LEN]) -> Field { + let mut f = 0; + let mut b = 1; + let mut len = LEN - 1; // FAILS + for i in 0..LEN { + let j = len - i; + f += (bytes[j] as Field) * b; + b *= 256; + } + f } diff --git a/crates/nargo_cli/tests/execution_success/global_consts/src/main.nr b/crates/nargo_cli/tests/execution_success/global_consts/src/main.nr index 2ed6e4593dd..13b9159b480 100644 --- a/crates/nargo_cli/tests/execution_success/global_consts/src/main.nr +++ b/crates/nargo_cli/tests/execution_success/global_consts/src/main.nr @@ -35,7 +35,7 @@ fn main(a: [Field; M + N - N], b: [Field; 30 + N / 2], c : pub [Field; foo::MAGI let mut y = 5; let mut x = M; for i in 0..N*N { - let M: comptime Field = 10; + let M: Field = 10; x = M; y = i; @@ -87,8 +87,8 @@ mod mysubmodule { assert(x | y == 1); } - fn my_helper() -> comptime Field { - let N: comptime Field = 15; // Like in Rust, local variables override globals + fn my_helper() -> Field { + let N: Field = 15; // Like in Rust, local variables override globals let x = N; x } diff --git a/crates/nargo_cli/tests/execution_success/references/src/main.nr b/crates/nargo_cli/tests/execution_success/references/src/main.nr index f70293cb5a6..aeed8e0b901 100644 --- a/crates/nargo_cli/tests/execution_success/references/src/main.nr +++ b/crates/nargo_cli/tests/execution_success/references/src/main.nr @@ -33,6 +33,7 @@ fn main(mut x: Field) { regression_1887(); regression_2054(); + regression_2030(); } fn add1(x: &mut Field) { @@ -87,3 +88,12 @@ fn regression_2054() { x += 1; assert(z == 2); } + +// The compiler was still trying to convert an LValue from an array of structs to struct of arrays indexing, +// even though this conversion was mostly removed elsewhere. +fn regression_2030() { + let ref = &mut 0; + let mut array = [ref, ref]; + let _ = *array[0]; + *array[0] = 1; +} diff --git a/crates/nargo_cli/tests/execution_success/regression/src/main.nr b/crates/nargo_cli/tests/execution_success/regression/src/main.nr index e01888dea37..54769c39709 100644 --- a/crates/nargo_cli/tests/execution_success/regression/src/main.nr +++ b/crates/nargo_cli/tests/execution_success/regression/src/main.nr @@ -1,4 +1,4 @@ -global NIBBLE_LENGTH: comptime Field = 16; +global NIBBLE_LENGTH: Field = 16; fn compact_decode(input: [u8; N], length: Field) -> ([u4; NIBBLE_LENGTH], Field) { @@ -87,4 +87,4 @@ fn main(x: [u8; 5], z: Field) assert(enc_val1.0 == [0x94,0xb8,0x8f,0x61,0xe6,0xfb,0xda,0x83,0xfb,0xff,0xfa,0xbe,0x36,0x41,0x12,0x13,0x74,0x80,0x39,0x80,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00]); assert(enc_val1.1 == 21); -} \ No newline at end of file +} diff --git a/crates/nargo_cli/tests/execution_success/slices/src/main.nr b/crates/nargo_cli/tests/execution_success/slices/src/main.nr index cda6657b4ff..ca1c4ac2966 100644 --- a/crates/nargo_cli/tests/execution_success/slices/src/main.nr +++ b/crates/nargo_cli/tests/execution_success/slices/src/main.nr @@ -43,6 +43,11 @@ fn main(x : Field, y : pub Field) { assert(remove_slice[3] == 3); assert(remove_slice.len() == 4); + let append = [1, 2].append([3, 4, 5]); + assert(append.len() == 5); + assert(append[0] == 1); + assert(append[4] == 5); + regression_2083(); } diff --git a/crates/nargo_toml/Cargo.toml b/crates/nargo_toml/Cargo.toml new file mode 100644 index 00000000000..f693403cd06 --- /dev/null +++ b/crates/nargo_toml/Cargo.toml @@ -0,0 +1,20 @@ +[package] +name = "nargo_toml" +description = "Utilities for working with Nargo.toml files" +version.workspace = true +authors.workspace = true +edition.workspace = true + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +dirs.workspace = true +fm.workspace = true +nargo.workspace = true +noirc_frontend.workspace = true +serde.workspace = true +thiserror.workspace = true +toml.workspace = true +url.workspace = true + +[dev-dependencies] diff --git a/crates/nargo_toml/src/errors.rs b/crates/nargo_toml/src/errors.rs new file mode 100644 index 00000000000..d15b4e8c535 --- /dev/null +++ b/crates/nargo_toml/src/errors.rs @@ -0,0 +1,60 @@ +use std::path::PathBuf; + +use nargo::package::PackageType; +use noirc_frontend::graph::CrateName; +use thiserror::Error; + +/// Errors covering situations where a package is either missing or malformed. +#[derive(Debug, Error)] +pub enum ManifestError { + /// Package doesn't have a manifest file + #[error("cannot find a Nargo.toml in {}", .0.display())] + MissingFile(PathBuf), + + #[error("Cannot read file {0} - does it exist?")] + ReadFailed(PathBuf), + + #[error("Nargo.toml is missing a parent directory")] + MissingParent, + + #[error("Missing `type` field in {0}")] + MissingPackageType(PathBuf), + + #[error("Cannot use `{1}` for `type` field in {0}")] + InvalidPackageType(PathBuf, String), + + /// Package manifest is unreadable. + #[error("Nargo.toml is badly formed, could not parse.\n\n {0}")] + MalformedFile(#[from] toml::de::Error), + + #[error("Unexpected workspace definition found in {0}")] + UnexpectedWorkspace(PathBuf), + + #[error("Cannot find file {entry} which was specified as the `entry` field in {toml}")] + MissingEntryFile { toml: PathBuf, entry: PathBuf }, + + #[error( + r#"Cannot find file {entry} which is defaulted due to specifying `type = "{package_type}"` in {toml}"# + )] + MissingDefaultEntryFile { toml: PathBuf, entry: PathBuf, package_type: PackageType }, + + /// Invalid character `-` in package name + #[error("invalid character `-` in package name")] + InvalidPackageName, + + /// Encountered error while downloading git repository. + #[error("{0}")] + GitError(String), + + #[error("Selected package `{0}` was not found")] + MissingSelectedPackage(CrateName), + + #[error("Default package was not found. Does {0} exist in your workspace?")] + MissingDefaultPackage(PathBuf), + + #[error("Package `{0}` has type `bin` but you cannot depend on binary packages")] + BinaryDependency(CrateName), + + #[error("Missing `name` field in {toml}")] + MissingNameField { toml: PathBuf }, +} diff --git a/crates/nargo_cli/src/git.rs b/crates/nargo_toml/src/git.rs similarity index 88% rename from crates/nargo_cli/src/git.rs rename to crates/nargo_toml/src/git.rs index 850657a8af1..80e57247ae6 100644 --- a/crates/nargo_cli/src/git.rs +++ b/crates/nargo_toml/src/git.rs @@ -9,10 +9,14 @@ fn resolve_folder_name(base: &url::Url, tag: &str) -> String { folder_name } -pub(crate) fn git_dep_location(base: &url::Url, tag: &str) -> PathBuf { +fn nargo_crates() -> PathBuf { + dirs::home_dir().unwrap().join("nargo") +} + +fn git_dep_location(base: &url::Url, tag: &str) -> PathBuf { let folder_name = resolve_folder_name(base, tag); - super::nargo_crates().join(folder_name) + nargo_crates().join(folder_name) } /// XXX: I'd prefer to use a GitHub library however, there diff --git a/crates/nargo_cli/src/manifest.rs b/crates/nargo_toml/src/lib.rs similarity index 85% rename from crates/nargo_cli/src/manifest.rs rename to crates/nargo_toml/src/lib.rs index b7b1d6d2d5c..4a9238ee021 100644 --- a/crates/nargo_cli/src/manifest.rs +++ b/crates/nargo_toml/src/lib.rs @@ -1,5 +1,6 @@ use std::{ collections::BTreeMap, + fs::ReadDir, path::{Path, PathBuf}, }; @@ -11,7 +12,55 @@ use nargo::{ use noirc_frontend::graph::CrateName; use serde::Deserialize; -use crate::{errors::ManifestError, git::clone_git_repo}; +mod errors; +mod git; + +pub use errors::ManifestError; +use git::clone_git_repo; + +/// Returns the path of the root directory of the package containing `current_path`. +/// +/// Returns a `CliError` if no parent directories of `current_path` contain a manifest file. +pub fn find_package_root(current_path: &Path) -> Result { + let manifest_path = find_package_manifest(current_path)?; + + let package_root = + manifest_path.parent().expect("infallible: manifest file path can't be root directory"); + + Ok(package_root.to_path_buf()) +} + +/// Returns the path of the manifest file (`Nargo.toml`) of the package containing `current_path`. +/// +/// Returns a `CliError` if no parent directories of `current_path` contain a manifest file. +pub fn find_package_manifest(current_path: &Path) -> Result { + current_path + .ancestors() + .find_map(|dir| find_file(dir, "Nargo", "toml")) + .ok_or_else(|| ManifestError::MissingFile(current_path.to_path_buf())) +} + +// Looks for file named `file_name` in path +fn find_file>(path: P, file_name: &str, extension: &str) -> Option { + let entries = list_files_and_folders_in(path)?; + let file_name = format!("{file_name}.{extension}"); + + find_artifact(entries, &file_name) +} + +// There is no distinction between files and folders +fn find_artifact(entries: ReadDir, artifact_name: &str) -> Option { + let entry = entries + .into_iter() + .flatten() + .find(|entry| entry.file_name().to_str() == Some(artifact_name))?; + + Some(entry.path()) +} + +fn list_files_and_folders_in>(path: P) -> Option { + std::fs::read_dir(path).ok() +} #[derive(Debug, Deserialize, Clone)] struct PackageConfig { @@ -39,6 +88,7 @@ impl PackageConfig { let package_type = match self.package.package_type.as_deref() { Some("lib") => PackageType::Library, Some("bin") => PackageType::Binary, + Some("contract") => PackageType::Contract, Some(invalid) => { return Err(ManifestError::InvalidPackageType( root_dir.join("Nargo.toml"), @@ -63,7 +113,7 @@ impl PackageConfig { PackageType::Library => { root_dir.join("src").join("lib").with_extension(FILE_EXTENSION) } - PackageType::Binary => { + PackageType::Binary | PackageType::Contract => { root_dir.join("src").join("main").with_extension(FILE_EXTENSION) } }; @@ -276,7 +326,7 @@ fn resolve_package_from_toml(toml_path: &Path) -> Result } /// Resolves a Nargo.toml file into a `Workspace` struct as defined by our `nargo` core. -pub(crate) fn resolve_workspace_from_toml( +pub fn resolve_workspace_from_toml( toml_path: &Path, selected_package: Option, ) -> Result { diff --git a/crates/noirc_driver/src/lib.rs b/crates/noirc_driver/src/lib.rs index 6b9ab2c996d..2919d2fd3ea 100644 --- a/crates/noirc_driver/src/lib.rs +++ b/crates/noirc_driver/src/lib.rs @@ -179,6 +179,7 @@ pub fn compile_contracts( ) -> Result<(Vec, Warnings), ErrorsAndWarnings> { let warnings = check_crate(context, crate_id, options.deny_warnings)?; + // TODO: We probably want to error if contracts is empty let contracts = context.get_all_contracts(&crate_id); let mut compiled_contracts = vec![]; let mut errors = warnings; diff --git a/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs index 6af911e718f..943826201d2 100644 --- a/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs +++ b/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs @@ -109,7 +109,7 @@ impl<'block> BrilligBlock<'block> { self.create_block_label_for_current_function(*else_destination), ); } - TerminatorInstruction::Jmp { destination, arguments } => { + TerminatorInstruction::Jmp { destination, arguments, location: _ } => { let target = &dfg[*destination]; for (src, dest) in arguments.iter().zip(target.parameters()) { // Destination variable might have already been created by another block that jumps to this target diff --git a/crates/noirc_evaluator/src/errors.rs b/crates/noirc_evaluator/src/errors.rs index 038210f86e1..981f0c9f8a7 100644 --- a/crates/noirc_evaluator/src/errors.rs +++ b/crates/noirc_evaluator/src/errors.rs @@ -30,6 +30,8 @@ pub enum RuntimeError { UnInitialized { name: String, location: Option }, #[error("Integer sized {num_bits:?} is over the max supported size of {max_num_bits:?}")] UnsupportedIntegerSize { num_bits: u32, max_num_bits: u32, location: Option }, + #[error("Could not determine loop bound at compile-time")] + UnknownLoopBound { location: Option }, } #[derive(Debug, PartialEq, Eq, Clone, Error)] @@ -50,34 +52,36 @@ pub enum InternalError { UnExpected { expected: String, found: String, location: Option }, } -impl From for FileDiagnostic { - fn from(error: RuntimeError) -> Self { - match error { - RuntimeError::InternalError(ref ice_error) => match ice_error { +impl RuntimeError { + fn location(&self) -> Option { + match self { + RuntimeError::InternalError( InternalError::DegreeNotReduced { location } | InternalError::EmptyArray { location } | InternalError::General { location, .. } | InternalError::MissingArg { location, .. } | InternalError::NotAConstant { location, .. } | InternalError::UndeclaredAcirVar { location } - | InternalError::UnExpected { location, .. } => { - let file_id = location.map(|loc| loc.file).unwrap(); - FileDiagnostic { file_id, diagnostic: error.into() } - } - }, - RuntimeError::FailedConstraint { location, .. } + | InternalError::UnExpected { location, .. }, + ) + | RuntimeError::FailedConstraint { location, .. } | RuntimeError::IndexOutOfBounds { location, .. } | RuntimeError::InvalidRangeConstraint { location, .. } | RuntimeError::TypeConversion { location, .. } | RuntimeError::UnInitialized { location, .. } - | RuntimeError::UnsupportedIntegerSize { location, .. } => { - let file_id = location.map(|loc| loc.file).unwrap(); - FileDiagnostic { file_id, diagnostic: error.into() } - } + | RuntimeError::UnknownLoopBound { location, .. } + | RuntimeError::UnsupportedIntegerSize { location, .. } => *location, } } } +impl From for FileDiagnostic { + fn from(error: RuntimeError) -> Self { + let file_id = error.location().map(|loc| loc.file).unwrap(); + FileDiagnostic { file_id, diagnostic: error.into() } + } +} + impl From for Diagnostic { fn from(error: RuntimeError) -> Diagnostic { match error { @@ -87,13 +91,8 @@ impl From for Diagnostic { "".to_string(), noirc_errors::Span::new(0..0) ), - RuntimeError::FailedConstraint { location, .. } - | RuntimeError::IndexOutOfBounds { location, .. } - | RuntimeError::InvalidRangeConstraint { location, .. } - | RuntimeError::TypeConversion { location, .. } - | RuntimeError::UnInitialized { location, .. } - | RuntimeError::UnsupportedIntegerSize { location, .. } => { - let span = if let Some(loc) = location { loc.span } else { noirc_errors::Span::new(0..0) }; + _ => { + let span = if let Some(loc) = error.location() { loc.span } else { noirc_errors::Span::new(0..0) }; Diagnostic::simple_error("".to_owned(), error.to_string(), span) } } diff --git a/crates/noirc_evaluator/src/ssa.rs b/crates/noirc_evaluator/src/ssa.rs index 81982e463a0..5f29027669a 100644 --- a/crates/noirc_evaluator/src/ssa.rs +++ b/crates/noirc_evaluator/src/ssa.rs @@ -49,7 +49,7 @@ pub(crate) fn optimize_into_acir( ssa = ssa .inline_functions() .print(print_ssa_passes, "After Inlining:") - .unroll_loops() + .unroll_loops()? .print(print_ssa_passes, "After Unrolling:") .simplify_cfg() .print(print_ssa_passes, "After Simplifying:") diff --git a/crates/noirc_evaluator/src/ssa/acir_gen/mod.rs b/crates/noirc_evaluator/src/ssa/acir_gen/mod.rs index 81b3aefcb79..0b4e364fd27 100644 --- a/crates/noirc_evaluator/src/ssa/acir_gen/mod.rs +++ b/crates/noirc_evaluator/src/ssa/acir_gen/mod.rs @@ -24,11 +24,7 @@ use crate::brillig::{brillig_gen::brillig_fn::FunctionContext as BrilligFunction use crate::errors::{InternalError, RuntimeError}; pub(crate) use acir_ir::generated_acir::GeneratedAcir; use acvm::{ - acir::{ - brillig::Opcode, - circuit::opcodes::BlockId, - native_types::{Expression, Witness}, - }, + acir::{brillig::Opcode, circuit::opcodes::BlockId, native_types::Expression}, FieldElement, }; use iter_extended::{try_vecmap, vecmap}; @@ -123,19 +119,17 @@ impl Ssa { match abi_distinctness { AbiDistinctness::Distinct => { - let mut distinct_return_witness: Vec = - Vec::with_capacity(generated_acir.return_witnesses.len()); - - for mut return_witness in generated_acir.return_witnesses.clone() { - // If witness has already been used then create a new one - // to guarantee that the return witnesses are distinct - if distinct_return_witness.contains(&return_witness) { - return_witness = generated_acir - .create_witness_for_expression(&Expression::from(return_witness)); - } - - distinct_return_witness.push(return_witness); - } + // Create a witness for each return witness we have + // to guarantee that the return witnesses are distinct + let distinct_return_witness: Vec<_> = generated_acir + .return_witnesses + .clone() + .into_iter() + .map(|return_witness| { + generated_acir + .create_witness_for_expression(&Expression::from(return_witness)) + }) + .collect(); generated_acir.return_witnesses = distinct_return_witness; Ok(generated_acir) diff --git a/crates/noirc_evaluator/src/ssa/ir/cfg.rs b/crates/noirc_evaluator/src/ssa/ir/cfg.rs index a91123438fa..8faa0fa8565 100644 --- a/crates/noirc_evaluator/src/ssa/ir/cfg.rs +++ b/crates/noirc_evaluator/src/ssa/ir/cfg.rs @@ -220,6 +220,7 @@ mod tests { func.dfg[block2_id].set_terminator(TerminatorInstruction::Jmp { destination: ret_block_id, arguments: vec![], + location: None, }); func.dfg[block0_id].set_terminator(TerminatorInstruction::JmpIf { condition: cond, diff --git a/crates/noirc_evaluator/src/ssa/ir/dfg.rs b/crates/noirc_evaluator/src/ssa/ir/dfg.rs index 1dd54499632..f8b5146b2ed 100644 --- a/crates/noirc_evaluator/src/ssa/ir/dfg.rs +++ b/crates/noirc_evaluator/src/ssa/ir/dfg.rs @@ -408,11 +408,11 @@ impl DataFlowGraph { } pub(crate) fn get_location(&self, id: &InstructionId) -> Option { - self.locations.get(id).cloned() + self.locations.get(id).copied() } pub(crate) fn get_value_location(&self, id: &ValueId) -> Option { - match &self.values[*id] { + match &self.values[self.resolve(*id)] { Value::Instruction { instruction, .. } => self.get_location(instruction), _ => None, } diff --git a/crates/noirc_evaluator/src/ssa/ir/instruction.rs b/crates/noirc_evaluator/src/ssa/ir/instruction.rs index e5353f8348b..cb6bb83ab61 100644 --- a/crates/noirc_evaluator/src/ssa/ir/instruction.rs +++ b/crates/noirc_evaluator/src/ssa/ir/instruction.rs @@ -1,5 +1,6 @@ use acvm::{acir::BlackBoxFunc, FieldElement}; use iter_extended::vecmap; +use noirc_errors::Location; use num_bigint::BigUint; use super::{ @@ -422,8 +423,10 @@ pub(crate) enum TerminatorInstruction { /// Unconditional Jump /// - /// Jumps to specified `destination` with `arguments` - Jmp { destination: BasicBlockId, arguments: Vec }, + /// Jumps to specified `destination` with `arguments`. + /// The optional Location here is expected to be used to issue an error when the start range of + /// a for loop cannot be deduced at compile-time. + Jmp { destination: BasicBlockId, arguments: Vec, location: Option }, /// Return from the current function with the given return values. /// @@ -448,9 +451,11 @@ impl TerminatorInstruction { then_destination: *then_destination, else_destination: *else_destination, }, - Jmp { destination, arguments } => { - Jmp { destination: *destination, arguments: vecmap(arguments, |value| f(*value)) } - } + Jmp { destination, arguments, location } => Jmp { + destination: *destination, + arguments: vecmap(arguments, |value| f(*value)), + location: *location, + }, Return { return_values } => { Return { return_values: vecmap(return_values, |value| f(*value)) } } @@ -596,6 +601,11 @@ impl Binary { let zero = dfg.make_constant(FieldElement::zero(), Type::bool()); return SimplifyResult::SimplifiedTo(zero); } + if operand_type.is_unsigned() && rhs_is_zero { + // Unsigned values cannot be less than zero. + let zero = dfg.make_constant(FieldElement::zero(), Type::bool()); + return SimplifyResult::SimplifiedTo(zero); + } } BinaryOp::And => { if lhs_is_zero || rhs_is_zero { diff --git a/crates/noirc_evaluator/src/ssa/ir/printer.rs b/crates/noirc_evaluator/src/ssa/ir/printer.rs index f2fb90b3464..e6faf4570c5 100644 --- a/crates/noirc_evaluator/src/ssa/ir/printer.rs +++ b/crates/noirc_evaluator/src/ssa/ir/printer.rs @@ -100,7 +100,7 @@ pub(crate) fn display_terminator( f: &mut Formatter, ) -> Result { match terminator { - Some(TerminatorInstruction::Jmp { destination, arguments }) => { + Some(TerminatorInstruction::Jmp { destination, arguments, location: _ }) => { writeln!(f, " jmp {}({})", destination, value_list(function, arguments)) } Some(TerminatorInstruction::JmpIf { condition, then_destination, else_destination }) => { diff --git a/crates/noirc_evaluator/src/ssa/ir/types.rs b/crates/noirc_evaluator/src/ssa/ir/types.rs index 38dd6125121..e8110f0901b 100644 --- a/crates/noirc_evaluator/src/ssa/ir/types.rs +++ b/crates/noirc_evaluator/src/ssa/ir/types.rs @@ -37,6 +37,11 @@ pub(crate) enum Type { } impl Type { + /// Returns whether the `Type` represents an unsigned numeric type. + pub(crate) fn is_unsigned(&self) -> bool { + matches!(self, Type::Numeric(NumericType::Unsigned { .. })) + } + /// Create a new signed integer type with the given amount of bits. pub(crate) fn signed(bit_size: u32) -> Type { Type::Numeric(NumericType::Signed { bit_size }) diff --git a/crates/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/crates/noirc_evaluator/src/ssa/opt/flatten_cfg.rs index 1bcdf433d79..8481f5610bb 100644 --- a/crates/noirc_evaluator/src/ssa/opt/flatten_cfg.rs +++ b/crates/noirc_evaluator/src/ssa/opt/flatten_cfg.rs @@ -285,7 +285,7 @@ impl<'f> Context<'f> { let end = self.branch_ends[&block]; self.inline_branch_end(end, then_branch, else_branch) } - TerminatorInstruction::Jmp { destination, arguments } => { + TerminatorInstruction::Jmp { destination, arguments, location: _ } => { if let Some((end_block, _)) = self.conditions.last() { if destination == end_block { return block; diff --git a/crates/noirc_evaluator/src/ssa/opt/inlining.rs b/crates/noirc_evaluator/src/ssa/opt/inlining.rs index d4c118fd3f4..36398bd98fe 100644 --- a/crates/noirc_evaluator/src/ssa/opt/inlining.rs +++ b/crates/noirc_evaluator/src/ssa/opt/inlining.rs @@ -433,10 +433,14 @@ impl<'function> PerFunctionContext<'function> { block_queue: &mut Vec, ) -> Option<(BasicBlockId, Vec)> { match self.source_function.dfg[block_id].unwrap_terminator() { - TerminatorInstruction::Jmp { destination, arguments } => { + TerminatorInstruction::Jmp { destination, arguments, location } => { let destination = self.translate_block(*destination, block_queue); let arguments = vecmap(arguments, |arg| self.translate_value(*arg)); - self.context.builder.terminate_with_jmp(destination, arguments); + self.context.builder.terminate_with_jmp_with_location( + destination, + arguments, + *location, + ); None } TerminatorInstruction::JmpIf { condition, then_destination, else_destination } => { diff --git a/crates/noirc_evaluator/src/ssa/opt/simplify_cfg.rs b/crates/noirc_evaluator/src/ssa/opt/simplify_cfg.rs index 58259cec90c..26c7b161550 100644 --- a/crates/noirc_evaluator/src/ssa/opt/simplify_cfg.rs +++ b/crates/noirc_evaluator/src/ssa/opt/simplify_cfg.rs @@ -86,7 +86,8 @@ fn check_for_constant_jmpif( let destination = if constant.is_zero() { *else_destination } else { *then_destination }; - let jmp = TerminatorInstruction::Jmp { destination, arguments: Vec::new() }; + let arguments = Vec::new(); + let jmp = TerminatorInstruction::Jmp { destination, arguments, location: None }; function.dfg[block].set_terminator(jmp); cfg.recompute_block(function, block); } diff --git a/crates/noirc_evaluator/src/ssa/opt/unrolling.rs b/crates/noirc_evaluator/src/ssa/opt/unrolling.rs index f6d7c952277..ac38f102712 100644 --- a/crates/noirc_evaluator/src/ssa/opt/unrolling.rs +++ b/crates/noirc_evaluator/src/ssa/opt/unrolling.rs @@ -7,30 +7,42 @@ //! b. If we have previously modified any of the blocks in the loop, //! restart from step 1 to refresh the context. //! c. If not, try to unroll the loop. If successful, remember the modified -//! blocks. If not, remember that the loop failed to unroll and leave it -//! unmodified. +//! blocks. If unsuccessfuly either error if the abort_on_error flag is set, +//! or otherwise remember that the loop failed to unroll and leave it unmodified. //! //! Note that this pass also often creates superfluous jmp instructions in the //! program that will need to be removed by a later simplify cfg pass. use std::collections::{HashMap, HashSet}; -use crate::ssa::{ - ir::{ - basic_block::BasicBlockId, cfg::ControlFlowGraph, dfg::DataFlowGraph, dom::DominatorTree, - function::Function, function_inserter::FunctionInserter, - instruction::TerminatorInstruction, post_order::PostOrder, value::ValueId, +use noirc_errors::Location; + +use crate::{ + errors::RuntimeError, + ssa::{ + ir::{ + basic_block::BasicBlockId, + cfg::ControlFlowGraph, + dfg::DataFlowGraph, + dom::DominatorTree, + function::{Function, RuntimeType}, + function_inserter::FunctionInserter, + instruction::TerminatorInstruction, + post_order::PostOrder, + value::ValueId, + }, + ssa_gen::Ssa, }, - ssa_gen::Ssa, }; impl Ssa { /// Unroll all loops in each SSA function. /// If any loop cannot be unrolled, it is left as-is or in a partially unrolled state. - pub(crate) fn unroll_loops(mut self) -> Ssa { + pub(crate) fn unroll_loops(mut self) -> Result { for function in self.functions.values_mut() { - find_all_loops(function).unroll_each_loop(function); + let abort_on_error = function.runtime() == RuntimeType::Acir; + find_all_loops(function).unroll_each_loop(function, abort_on_error)?; } - self + Ok(self) } } @@ -96,25 +108,34 @@ fn find_all_loops(function: &Function) -> Loops { impl Loops { /// Unroll all loops within a given function. /// Any loops which fail to be unrolled (due to using non-constant indices) will be unmodified. - fn unroll_each_loop(mut self, function: &mut Function) { + fn unroll_each_loop( + mut self, + function: &mut Function, + abort_on_error: bool, + ) -> Result<(), RuntimeError> { while let Some(next_loop) = self.yet_to_unroll.pop() { // If we've previously modified a block in this loop we need to refresh the context. // This happens any time we have nested loops. if next_loop.blocks.iter().any(|block| self.modified_blocks.contains(block)) { let mut new_context = find_all_loops(function); new_context.failed_to_unroll = self.failed_to_unroll; - return new_context.unroll_each_loop(function); + return new_context.unroll_each_loop(function, abort_on_error); } // Don't try to unroll the loop again if it is known to fail if !self.failed_to_unroll.contains(&next_loop.header) { - if unroll_loop(function, &self.cfg, &next_loop).is_ok() { - self.modified_blocks.extend(next_loop.blocks); - } else { - self.failed_to_unroll.insert(next_loop.header); + match unroll_loop(function, &self.cfg, &next_loop) { + Ok(_) => self.modified_blocks.extend(next_loop.blocks), + Err(location) if abort_on_error => { + return Err(RuntimeError::UnknownLoopBound { location }); + } + Err(_) => { + self.failed_to_unroll.insert(next_loop.header); + } } } } + Ok(()) } } @@ -151,7 +172,11 @@ fn find_blocks_in_loop( /// Unroll a single loop in the function. /// Returns Err(()) if it failed to unroll and Ok(()) otherwise. -fn unroll_loop(function: &mut Function, cfg: &ControlFlowGraph, loop_: &Loop) -> Result<(), ()> { +fn unroll_loop( + function: &mut Function, + cfg: &ControlFlowGraph, + loop_: &Loop, +) -> Result<(), Option> { let mut unroll_into = get_pre_header(cfg, loop_); let mut jump_value = get_induction_variable(function, unroll_into)?; @@ -181,9 +206,12 @@ fn get_pre_header(cfg: &ControlFlowGraph, loop_: &Loop) -> BasicBlockId { /// /// Expects the current block to terminate in `jmp h(N)` where h is the loop header and N is /// a Field value. -fn get_induction_variable(function: &Function, block: BasicBlockId) -> Result { +fn get_induction_variable( + function: &Function, + block: BasicBlockId, +) -> Result> { match function.dfg[block].terminator() { - Some(TerminatorInstruction::Jmp { arguments, .. }) => { + Some(TerminatorInstruction::Jmp { arguments, location, .. }) => { // This assumption will no longer be valid if e.g. mutable variables are represented as // block parameters. If that becomes the case we'll need to figure out which variable // is generally constant and increasing to guess which parameter is the induction @@ -193,10 +221,10 @@ fn get_induction_variable(function: &Function, block: BasicBlockId) -> Result Err(()), + _ => Err(None), } } @@ -208,7 +236,7 @@ fn unroll_loop_header<'a>( loop_: &'a Loop, unroll_into: BasicBlockId, induction_value: ValueId, -) -> Result>, ()> { +) -> Result>, Option> { // We insert into a fresh block first and move instructions into the unroll_into block later // only once we verify the jmpif instruction has a constant condition. If it does not, we can // just discard this fresh block and leave the loop unmodified. @@ -225,7 +253,8 @@ fn unroll_loop_header<'a>( match context.dfg()[fresh_block].unwrap_terminator() { TerminatorInstruction::JmpIf { condition, then_destination, else_destination } => { - let next_blocks = context.handle_jmpif(*condition, *then_destination, *else_destination); + let condition = *condition; + let next_blocks = context.handle_jmpif(condition, *then_destination, *else_destination); // If there is only 1 next block the jmpif evaluated to a single known block. // This is the expected case and lets us know if we should loop again or not. @@ -240,7 +269,7 @@ fn unroll_loop_header<'a>( } else { // If this case is reached the loop either uses non-constant indices or we need // another pass, such as mem2reg to resolve them to constants. - Err(()) + Err(context.inserter.function.dfg.get_value_location(&condition)) } } other => unreachable!("Expected loop header to terminate in a JmpIf to the loop body, but found {other:?} instead"), @@ -332,7 +361,7 @@ impl<'f> LoopIteration<'f> { TerminatorInstruction::JmpIf { condition, then_destination, else_destination } => { self.handle_jmpif(*condition, *then_destination, *else_destination) } - TerminatorInstruction::Jmp { destination, arguments } => { + TerminatorInstruction::Jmp { destination, arguments, location: _ } => { if self.get_original_block(*destination) == self.loop_.header { assert_eq!(arguments.len(), 1); self.induction_value = Some((self.insert_block, arguments[0])); @@ -361,7 +390,8 @@ impl<'f> LoopIteration<'f> { self.source_block = self.get_original_block(destination); - let jmp = TerminatorInstruction::Jmp { destination, arguments: Vec::new() }; + let arguments = Vec::new(); + let jmp = TerminatorInstruction::Jmp { destination, arguments, location: None }; self.inserter.function.dfg.set_block_terminator(self.insert_block, jmp); vec![destination] } @@ -547,7 +577,7 @@ mod tests { // } // The final block count is not 1 because unrolling creates some unnecessary jmps. // If a simplify cfg pass is ran afterward, the expected block count will be 1. - let ssa = ssa.unroll_loops(); + let ssa = ssa.unroll_loops().expect("All loops should be unrolled"); assert_eq!(ssa.main().reachable_blocks().len(), 5); } @@ -595,8 +625,7 @@ mod tests { let ssa = builder.finish(); assert_eq!(ssa.main().reachable_blocks().len(), 4); - // Expected ssa is unchanged - let ssa = ssa.unroll_loops(); - assert_eq!(ssa.main().reachable_blocks().len(), 4); + // Expected that we failed to unroll the loop + assert!(ssa.unroll_loops().is_err()); } } diff --git a/crates/noirc_evaluator/src/ssa/ssa_builder/mod.rs b/crates/noirc_evaluator/src/ssa/ssa_builder/mod.rs index 066b5b51199..61daa06e37b 100644 --- a/crates/noirc_evaluator/src/ssa/ssa_builder/mod.rs +++ b/crates/noirc_evaluator/src/ssa/ssa_builder/mod.rs @@ -281,7 +281,19 @@ impl FunctionBuilder { destination: BasicBlockId, arguments: Vec, ) { - self.terminate_block_with(TerminatorInstruction::Jmp { destination, arguments }); + self.terminate_with_jmp_with_location(destination, arguments, None); + } + + /// Terminate the current block with a jmp instruction to jmp to the given + /// block with the given arguments. This version also remembers the Location of the jmp + /// for issuing error messages. + pub(crate) fn terminate_with_jmp_with_location( + &mut self, + destination: BasicBlockId, + arguments: Vec, + location: Option, + ) { + self.terminate_block_with(TerminatorInstruction::Jmp { destination, arguments, location }); } /// Terminate the current block with a jmpif instruction to jmp with the given arguments diff --git a/crates/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/crates/noirc_evaluator/src/ssa/ssa_gen/mod.rs index 65129f1f933..11c42d8b051 100644 --- a/crates/noirc_evaluator/src/ssa/ssa_gen/mod.rs +++ b/crates/noirc_evaluator/src/ssa/ssa_gen/mod.rs @@ -298,13 +298,24 @@ impl<'a> FunctionContext<'a> { let index_type = Self::convert_non_tuple_type(&for_expr.index_type); let loop_index = self.builder.add_block_parameter(loop_entry, index_type); + self.builder.set_location(for_expr.start_range_location); let start_index = self.codegen_non_tuple_expression(&for_expr.start_range); + + self.builder.set_location(for_expr.end_range_location); let end_index = self.codegen_non_tuple_expression(&for_expr.end_range); - self.builder.terminate_with_jmp(loop_entry, vec![start_index]); + // Set the location of the initial jmp instruction to the start range. This is the location + // used to issue an error if the start range cannot be determined at compile-time. + let jmp_location = Some(for_expr.start_range_location); + self.builder.terminate_with_jmp_with_location(loop_entry, vec![start_index], jmp_location); // Compile the loop entry block self.builder.switch_to_block(loop_entry); + + // Set the location of the ending Lt instruction and the jmpif back-edge of the loop to the + // end range. These are the instructions used to issue an error if the end of the range + // cannot be determined at compile-time. + self.builder.set_location(for_expr.end_range_location); let jump_condition = self.builder.insert_binary(loop_index, BinaryOp::Lt, end_index); self.builder.terminate_with_jmpif(jump_condition, loop_body, loop_end); diff --git a/crates/noirc_frontend/src/ast/mod.rs b/crates/noirc_frontend/src/ast/mod.rs index 6aa373c66a9..1934c3f790c 100644 --- a/crates/noirc_frontend/src/ast/mod.rs +++ b/crates/noirc_frontend/src/ast/mod.rs @@ -23,7 +23,7 @@ pub use type_alias::*; use crate::{ parser::{ParserError, ParserErrorReason}, token::IntType, - BinaryTypeOperator, CompTime, + BinaryTypeOperator, }; use iter_extended::vecmap; @@ -32,10 +32,10 @@ use iter_extended::vecmap; /// for structs within, but are otherwise identical to Types. #[derive(Debug, PartialEq, Eq, Clone, Hash)] pub enum UnresolvedType { - FieldElement(CompTime), + FieldElement, Array(Option, Box), // [4]Witness = Array(4, Witness) - Integer(CompTime, Signedness, u32), // u32 = Integer(unsigned, 32) - Bool(CompTime), + Integer(Signedness, u32), // u32 = Integer(unsigned, 32) + Bool, Expression(UnresolvedTypeExpression), String(Option), FormatString(UnresolvedTypeExpression, Box), @@ -81,14 +81,14 @@ impl std::fmt::Display for UnresolvedType { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { use UnresolvedType::*; match self { - FieldElement(is_const) => write!(f, "{is_const}Field"), + FieldElement => write!(f, "Field"), Array(len, typ) => match len { None => write!(f, "[{typ}]"), Some(len) => write!(f, "[{typ}; {len}]"), }, - Integer(is_const, sign, num_bits) => match sign { - Signedness::Signed => write!(f, "{is_const}i{num_bits}"), - Signedness::Unsigned => write!(f, "{is_const}u{num_bits}"), + Integer(sign, num_bits) => match sign { + Signedness::Signed => write!(f, "i{num_bits}"), + Signedness::Unsigned => write!(f, "u{num_bits}"), }, Named(s, args) => { let args = vecmap(args, ToString::to_string); @@ -103,7 +103,7 @@ impl std::fmt::Display for UnresolvedType { write!(f, "({})", elements.join(", ")) } Expression(expression) => expression.fmt(f), - Bool(is_const) => write!(f, "{is_const}bool"), + Bool => write!(f, "bool"), String(len) => match len { None => write!(f, "str<_>"), Some(len) => write!(f, "str<{len}>"), @@ -134,11 +134,11 @@ impl std::fmt::Display for UnresolvedTypeExpression { } impl UnresolvedType { - pub fn from_int_token(token: (CompTime, IntType)) -> UnresolvedType { + pub fn from_int_token(token: IntType) -> UnresolvedType { use {IntType::*, UnresolvedType::Integer}; - match token.1 { - Signed(num_bits) => Integer(token.0, Signedness::Signed, num_bits), - Unsigned(num_bits) => Integer(token.0, Signedness::Unsigned, num_bits), + match token { + Signed(num_bits) => Integer(Signedness::Signed, num_bits), + Unsigned(num_bits) => Integer(Signedness::Unsigned, num_bits), } } } diff --git a/crates/noirc_frontend/src/hir/def_collector/dc_crate.rs b/crates/noirc_frontend/src/hir/def_collector/dc_crate.rs index 2beebf6871c..631f0cf86e4 100644 --- a/crates/noirc_frontend/src/hir/def_collector/dc_crate.rs +++ b/crates/noirc_frontend/src/hir/def_collector/dc_crate.rs @@ -13,7 +13,8 @@ use crate::hir::Context; use crate::node_interner::{FuncId, NodeInterner, StmtId, StructId, TypeAliasId}; use crate::{ ExpressionKind, Generics, Ident, LetStatement, Literal, NoirFunction, NoirStruct, - NoirTypeAlias, ParsedModule, Shared, Type, TypeBinding, UnresolvedGenerics, UnresolvedType, + NoirTypeAlias, ParsedModule, Shared, StructType, Type, TypeBinding, UnresolvedGenerics, + UnresolvedType, }; use fm::FileId; use iter_extended::vecmap; @@ -233,7 +234,19 @@ fn collect_impls( extend_errors(errors, unresolved.file_id, resolver.take_errors()); - if let Some(type_module) = get_local_id_from_type(&typ) { + if let Some(struct_type) = get_struct_type(&typ) { + let struct_type = struct_type.borrow(); + let type_module = struct_type.id.0.local_id; + + // `impl`s are only allowed on types defined within the current crate + if struct_type.id.0.krate != crate_id { + let span = *span; + let type_name = struct_type.name.to_string(); + let error = DefCollectorErrorKind::ForeignImpl { span, type_name }; + errors.push(error.into_file_diagnostic(unresolved.file_id)); + continue; + } + // Grab the module defined by the struct type. Note that impls are a case // where the module the methods are added to is not the same as the module // they are resolved in. @@ -258,9 +271,9 @@ fn collect_impls( } } -fn get_local_id_from_type(typ: &Type) -> Option { +fn get_struct_type(typ: &Type) -> Option<&Shared> { match typ { - Type::Struct(definition, _) => Some(definition.borrow().id.0.local_id), + Type::Struct(definition, _) => Some(definition), _ => None, } } diff --git a/crates/noirc_frontend/src/hir/def_collector/errors.rs b/crates/noirc_frontend/src/hir/def_collector/errors.rs index d18df58d64d..03f528020f8 100644 --- a/crates/noirc_frontend/src/hir/def_collector/errors.rs +++ b/crates/noirc_frontend/src/hir/def_collector/errors.rs @@ -22,6 +22,8 @@ pub enum DefCollectorErrorKind { PathResolutionError(PathResolutionError), #[error("Non-struct type used in impl")] NonStructTypeInImpl { span: Span }, + #[error("Cannot `impl` a type defined outside the current crate")] + ForeignImpl { span: Span, type_name: String }, } impl DefCollectorErrorKind { @@ -101,6 +103,11 @@ impl From for Diagnostic { "Only struct types may have implementation methods".into(), span, ), + DefCollectorErrorKind::ForeignImpl { span, type_name } => Diagnostic::simple_error( + "Cannot `impl` a type that was defined outside the current crate".into(), + format!("{type_name} was defined outside the current crate"), + span, + ), } } } diff --git a/crates/noirc_frontend/src/hir/resolution/errors.rs b/crates/noirc_frontend/src/hir/resolution/errors.rs index e9cf8f31393..1215d897eda 100644 --- a/crates/noirc_frontend/src/hir/resolution/errors.rs +++ b/crates/noirc_frontend/src/hir/resolution/errors.rs @@ -42,8 +42,6 @@ pub enum ResolverError { NecessaryPub { ident: Ident }, #[error("'distinct' keyword can only be used with main method")] DistinctNotAllowed { ident: Ident }, - #[error("Expected const value where non-constant value was used")] - ExpectedComptimeVariable { name: String, span: Span }, #[error("Missing expression for declared constant")] MissingRhsExpr { name: String, span: Span }, #[error("Expression invalid in an array length context")] @@ -206,11 +204,6 @@ impl From for Diagnostic { diag.add_note("The `distinct` keyword is only valid when used on the main function of a program, as its only purpose is to ensure that all witness indices that occur in the abi are unique".to_owned()); diag } - ResolverError::ExpectedComptimeVariable { name, span } => Diagnostic::simple_error( - format!("expected constant variable where non-constant variable {name} was used"), - "expected const variable".to_string(), - span, - ), ResolverError::MissingRhsExpr { name, span } => Diagnostic::simple_error( format!( "no expression specifying the value stored by the constant variable {name}" diff --git a/crates/noirc_frontend/src/hir/resolution/resolver.rs b/crates/noirc_frontend/src/hir/resolution/resolver.rs index 681c853899f..6c154aade06 100644 --- a/crates/noirc_frontend/src/hir/resolution/resolver.rs +++ b/crates/noirc_frontend/src/hir/resolution/resolver.rs @@ -332,7 +332,7 @@ impl<'a> Resolver<'a> { /// freshly created TypeVariables created to new_variables. fn resolve_type_inner(&mut self, typ: UnresolvedType, new_variables: &mut Generics) -> Type { match typ { - UnresolvedType::FieldElement(comp_time) => Type::FieldElement(comp_time), + UnresolvedType::FieldElement => Type::FieldElement, UnresolvedType::Array(size, elem) => { let elem = Box::new(self.resolve_type_inner(*elem, new_variables)); let size = if size.is_none() { @@ -343,8 +343,8 @@ impl<'a> Resolver<'a> { Type::Array(Box::new(size), elem) } UnresolvedType::Expression(expr) => self.convert_expression_type(expr), - UnresolvedType::Integer(comp_time, sign, bits) => Type::Integer(comp_time, sign, bits), - UnresolvedType::Bool(comp_time) => Type::Bool(comp_time), + UnresolvedType::Integer(sign, bits) => Type::Integer(sign, bits), + UnresolvedType::Bool => Type::Bool, UnresolvedType::String(size) => { let resolved_size = self.resolve_array_size(size, new_variables); Type::String(Box::new(resolved_size)) @@ -816,9 +816,9 @@ impl<'a> Resolver<'a> { fn find_numeric_generics_in_type(typ: &Type, found: &mut HashMap>) { match typ { - Type::FieldElement(_) - | Type::Integer(_, _, _) - | Type::Bool(_) + Type::FieldElement + | Type::Integer(_, _) + | Type::Bool | Type::Unit | Type::Error | Type::TypeVariable(_, _) @@ -1008,7 +1008,16 @@ impl<'a> Resolver<'a> { match self.interner.definition(hir_ident.id).kind { DefinitionKind::Function(_) => {} DefinitionKind::Global(_) => {} - DefinitionKind::GenericType(_) => {} + DefinitionKind::GenericType(_) => { + // Initialize numeric generics to a polymorphic integer type in case + // they're used in expressions. We must do this here since the type + // checker does not check definition kinds and otherwise expects + // parameters to already be typed. + if self.interner.id_type(hir_ident.id) == Type::Error { + let typ = Type::polymorphic_integer(self.interner); + self.interner.push_definition_type(hir_ident.id, typ); + } + } // We ignore the above definition kinds because only local variables can be captured by closures. DefinitionKind::Local(_) => { self.resolve_local_variable(hir_ident, var_scope_index); diff --git a/crates/noirc_frontend/src/hir/type_check/errors.rs b/crates/noirc_frontend/src/hir/type_check/errors.rs index 8b3623db3c3..84bf511d314 100644 --- a/crates/noirc_frontend/src/hir/type_check/errors.rs +++ b/crates/noirc_frontend/src/hir/type_check/errors.rs @@ -47,14 +47,6 @@ pub enum TypeCheckError { AccessUnknownMember { lhs_type: Type, field_name: String, span: Span }, #[error("Function expects {expected} parameters but {found} given")] ParameterCountMismatch { expected: usize, found: usize, span: Span }, - #[error("The value is non-comptime because of this expression, which uses another non-comptime value")] - NotCompTime { span: Span }, - #[error( - "The value is comptime because of this expression, which forces the value to be comptime" - )] - CompTime { span: Span }, - #[error("Cannot cast to a comptime type, argument to cast is not known at compile-time")] - CannotCastToComptimeType { span: Span }, #[error("Only integer and Field types may be casted to")] UnsupportedCast { span: Span }, #[error("Index {index} is out of bounds for this tuple {lhs_type} of length {length}")] @@ -165,9 +157,6 @@ impl From for Diagnostic { TypeCheckError::InvalidCast { span, .. } | TypeCheckError::ExpectedFunction { span, .. } | TypeCheckError::AccessUnknownMember { span, .. } - | TypeCheckError::CompTime { span } - | TypeCheckError::NotCompTime { span } - | TypeCheckError::CannotCastToComptimeType { span } | TypeCheckError::UnsupportedCast { span } | TypeCheckError::TupleIndexOutOfBounds { span, .. } | TypeCheckError::VariableMustBeMutable { span, .. } diff --git a/crates/noirc_frontend/src/hir/type_check/expr.rs b/crates/noirc_frontend/src/hir/type_check/expr.rs index 5bc6aa45359..99b312adb0d 100644 --- a/crates/noirc_frontend/src/hir/type_check/expr.rs +++ b/crates/noirc_frontend/src/hir/type_check/expr.rs @@ -12,7 +12,7 @@ use crate::{ }, node_interner::{DefinitionKind, ExprId, FuncId}, token::Attribute::Deprecated, - CompTime, Shared, Signedness, TypeBinding, TypeVariableKind, UnaryOp, + Shared, Signedness, TypeBinding, TypeVariableKind, UnaryOp, }; use super::{errors::TypeCheckError, TypeChecker}; @@ -75,22 +75,17 @@ impl<'interner> TypeChecker<'interner> { for (index, elem_type) in elem_types.iter().enumerate().skip(1) { let location = self.interner.expr_location(&arr[index]); - elem_type.unify( - &first_elem_type, - location.span, - &mut self.errors, - || { - TypeCheckError::NonHomogeneousArray { - first_span: self.interner.expr_location(&arr[0]).span, - first_type: first_elem_type.to_string(), - first_index: index, - second_span: location.span, - second_type: elem_type.to_string(), - second_index: index + 1, - } - .add_context("elements in an array must have the same type") - }, - ); + elem_type.unify(&first_elem_type, &mut self.errors, || { + TypeCheckError::NonHomogeneousArray { + first_span: self.interner.expr_location(&arr[0]).span, + first_type: first_elem_type.to_string(), + first_index: index, + second_span: location.span, + second_type: elem_type.to_string(), + second_index: index + 1, + } + .add_context("elements in an array must have the same type") + }); } arr_type @@ -105,7 +100,7 @@ impl<'interner> TypeChecker<'interner> { }; Type::Array(Box::new(length), Box::new(elem_type)) } - HirLiteral::Bool(_) => Type::Bool(CompTime::new(self.interner)), + HirLiteral::Bool(_) => Type::Bool, HirLiteral::Integer(_) => Type::polymorphic_integer(self.interner), HirLiteral::Str(string) => { let len = Type::Constant(string.len() as u64); @@ -204,27 +199,18 @@ impl<'interner> TypeChecker<'interner> { // Check that start range and end range have the same types let range_span = start_span.merge(end_span); - self.unify(&start_range_type, &end_range_type, range_span, || { - TypeCheckError::TypeMismatch { - expected_typ: start_range_type.to_string(), - expr_typ: end_range_type.to_string(), - expr_span: range_span, - } + self.unify(&start_range_type, &end_range_type, || TypeCheckError::TypeMismatch { + expected_typ: start_range_type.to_string(), + expr_typ: end_range_type.to_string(), + expr_span: range_span, }); - let expected_comptime = if self.is_unconstrained() { - CompTime::new(self.interner) - } else { - CompTime::Yes(Some(range_span)) - }; let fresh_id = self.interner.next_type_variable_id(); let type_variable = Shared::new(TypeBinding::Unbound(fresh_id)); - let expected_type = Type::TypeVariable( - type_variable, - TypeVariableKind::IntegerOrField(expected_comptime), - ); + let expected_type = + Type::TypeVariable(type_variable, TypeVariableKind::IntegerOrField); - self.unify(&start_range_type, &expected_type, range_span, || { + self.unify(&start_range_type, &expected_type, || { TypeCheckError::TypeCannotBeUsed { typ: start_range_type.clone(), place: "for loop", @@ -252,12 +238,10 @@ impl<'interner> TypeChecker<'interner> { }; let span = self.interner.expr_span(&id); - self.unify(&expr_type, &Type::Unit, span, || { - TypeCheckError::TypeMismatch { - expected_typ: Type::Unit.to_string(), - expr_typ: expr_type.to_string(), - expr_span: span, - } + self.unify(&expr_type, &Type::Unit, || TypeCheckError::TypeMismatch { + expected_typ: Type::Unit.to_string(), + expr_typ: expr_type.to_string(), + expr_span: span, }); } else { block_type = expr_type; @@ -293,12 +277,10 @@ impl<'interner> TypeChecker<'interner> { let actual_return = self.check_expression(&lambda.body); let span = self.interner.expr_span(&lambda.body); - actual_return.make_subtype_of(&lambda.return_type, span, &mut self.errors, || { - TypeCheckError::TypeMismatch { - expected_typ: lambda.return_type.to_string(), - expr_typ: actual_return.to_string(), - expr_span: span, - } + self.unify(&actual_return, &lambda.return_type, || TypeCheckError::TypeMismatch { + expected_typ: lambda.return_type.to_string(), + expr_typ: actual_return.to_string(), + expr_span: span, }); Type::Function(params, Box::new(lambda.return_type), Box::new(env_type)) @@ -399,7 +381,7 @@ impl<'interner> TypeChecker<'interner> { let index_type = self.check_expression(&index_expr.index); let span = self.interner.expr_span(&index_expr.index); - index_type.unify(&Type::polymorphic_integer(self.interner), span, &mut self.errors, || { + index_type.unify(&Type::polymorphic_integer(self.interner), &mut self.errors, || { TypeCheckError::TypeMismatch { expected_typ: "an integer".to_owned(), expr_typ: index_type.to_string(), @@ -426,49 +408,27 @@ impl<'interner> TypeChecker<'interner> { } fn check_cast(&mut self, from: Type, to: Type, span: Span) -> Type { - let is_comp_time = match from.follow_bindings() { - Type::Integer(is_comp_time, ..) => is_comp_time, - Type::FieldElement(is_comp_time) => is_comp_time, - Type::TypeVariable(_, TypeVariableKind::IntegerOrField(is_comp_time)) => is_comp_time, + match from.follow_bindings() { + Type::Integer(..) + | Type::FieldElement + | Type::TypeVariable(_, TypeVariableKind::IntegerOrField) + | Type::Bool => (), + Type::TypeVariable(_, _) => { self.errors.push(TypeCheckError::TypeAnnotationsNeeded { span }); return Type::Error; } - Type::Bool(is_comp_time) => is_comp_time, Type::Error => return Type::Error, from => { self.errors.push(TypeCheckError::InvalidCast { from, span }); return Type::Error; } - }; + } match to { - Type::Integer(dest_comp_time, sign, bits) => { - if dest_comp_time.is_comp_time() - && is_comp_time.unify(&dest_comp_time, span).is_err() - { - self.errors.push(TypeCheckError::CannotCastToComptimeType { span }); - } - - Type::Integer(is_comp_time, sign, bits) - } - Type::FieldElement(dest_comp_time) => { - if dest_comp_time.is_comp_time() - && is_comp_time.unify(&dest_comp_time, span).is_err() - { - self.errors.push(TypeCheckError::CannotCastToComptimeType { span }); - } - - Type::FieldElement(is_comp_time) - } - Type::Bool(dest_comp_time) => { - if dest_comp_time.is_comp_time() - && is_comp_time.unify(&dest_comp_time, span).is_err() - { - self.errors.push(TypeCheckError::CannotCastToComptimeType { span }); - } - Type::Bool(dest_comp_time) - } + Type::Integer(sign, bits) => Type::Integer(sign, bits), + Type::FieldElement => Type::FieldElement, + Type::Bool => Type::Bool, Type::Error => Type::Error, _ => { self.errors.push(TypeCheckError::UnsupportedCast { span }); @@ -518,9 +478,8 @@ impl<'interner> TypeChecker<'interner> { let expr_span = self.interner.expr_span(&if_expr.condition); - let bool_type = Type::Bool(CompTime::new(self.interner)); - self.unify(&cond_type, &bool_type, expr_span, || TypeCheckError::TypeMismatch { - expected_typ: Type::Bool(CompTime::No(None)).to_string(), + self.unify(&cond_type, &Type::Bool, || TypeCheckError::TypeMismatch { + expected_typ: Type::Bool.to_string(), expr_typ: cond_type.to_string(), expr_span, }); @@ -531,7 +490,7 @@ impl<'interner> TypeChecker<'interner> { let else_type = self.check_expression(&alternative); let expr_span = self.interner.expr_span(expr_id); - self.unify(&then_type, &else_type, expr_span, || { + self.unify(&then_type, &else_type, || { let err = TypeCheckError::TypeMismatch { expected_typ: then_type.to_string(), expr_typ: else_type.to_string(), @@ -580,7 +539,7 @@ impl<'interner> TypeChecker<'interner> { let arg_type = self.check_expression(&arg); let span = self.interner.expr_span(expr_id); - self.make_subtype_of(&arg_type, ¶m_type, arg, || { + self.unify_with_coercions(&arg_type, ¶m_type, arg, || { TypeCheckError::TypeMismatch { expected_typ: param_type.to_string(), expr_typ: arg_type.to_string(), @@ -700,11 +659,11 @@ impl<'interner> TypeChecker<'interner> { match (lhs_type, rhs_type) { // Avoid reporting errors multiple times - (Error, _) | (_, Error) => Ok(Bool(CompTime::Yes(None))), + (Error, _) | (_, Error) => Ok(Bool), // Matches on TypeVariable must be first to follow any type // bindings. - (var @ TypeVariable(int, _), other) | (other, var @ TypeVariable(int, _)) => { + (TypeVariable(int, _), other) | (other, TypeVariable(int, _)) => { if let TypeBinding::Bound(binding) = &*int.borrow() { return self.comparator_operand_type_rules(other, binding, op, span); } @@ -721,11 +680,8 @@ impl<'interner> TypeChecker<'interner> { })); } - let comptime = var.try_get_comptime(); - if other.try_bind_to_polymorphic_int(int, &comptime, true, op.location.span).is_ok() - || other == &Type::Error - { - Ok(Bool(comptime.into_owned())) + if other.try_bind_to_polymorphic_int(int).is_ok() || other == &Type::Error { + Ok(Bool) } else { Err(TypeCheckError::TypeMismatchWithSource { rhs: lhs_type.clone(), @@ -735,10 +691,7 @@ impl<'interner> TypeChecker<'interner> { }) } } - ( - Integer(comptime_x, sign_x, bit_width_x), - Integer(comptime_y, sign_y, bit_width_y), - ) => { + (Integer(sign_x, bit_width_x), Integer(sign_y, bit_width_y)) => { if sign_x != sign_y { return Err(TypeCheckError::IntegerSignedness { sign_x: *sign_x, @@ -753,58 +706,48 @@ impl<'interner> TypeChecker<'interner> { span, }); } - let comptime = comptime_x.and(comptime_y, op.location.span); - Ok(Bool(comptime)) + Ok(Bool) } - (Integer(..), FieldElement(..)) | (FieldElement(..), Integer(..)) => { + (Integer(..), FieldElement) | (FieldElement, Integer(..)) => { Err(TypeCheckError::IntegerAndFieldBinaryOperation { span }) } (Integer(..), typ) | (typ, Integer(..)) => { Err(TypeCheckError::IntegerTypeMismatch { typ: typ.clone(), span }) } - (FieldElement(comptime_x), FieldElement(comptime_y)) => { + (FieldElement, FieldElement) => { if op.kind.is_valid_for_field_type() { - let comptime = comptime_x.and(comptime_y, op.location.span); - Ok(Bool(comptime)) + Ok(Bool) } else { Err(TypeCheckError::FieldComparison { span }) } } // <= and friends are technically valid for booleans, just not very useful - (Bool(comptime_x), Bool(comptime_y)) => { - let comptime = comptime_x.and(comptime_y, op.location.span); - Ok(Bool(comptime)) - } + (Bool, Bool) => Ok(Bool), // Special-case == and != for arrays (Array(x_size, x_type), Array(y_size, y_type)) if matches!(op.kind, Equal | NotEqual) => { - x_type.unify(y_type, op.location.span, &mut self.errors, || { - TypeCheckError::TypeMismatchWithSource { - rhs: lhs_type.clone(), - lhs: rhs_type.clone(), - source: Source::ArrayElements, - span: op.location.span, - } + self.unify(x_type, y_type, || TypeCheckError::TypeMismatchWithSource { + rhs: lhs_type.clone(), + lhs: rhs_type.clone(), + source: Source::ArrayElements, + span: op.location.span, }); - self.unify(x_size, y_size, op.location.span, || { - TypeCheckError::TypeMismatchWithSource { - rhs: lhs_type.clone(), - lhs: rhs_type.clone(), - source: Source::ArrayLen, - span: op.location.span, - } + self.unify(x_size, y_size, || TypeCheckError::TypeMismatchWithSource { + rhs: lhs_type.clone(), + lhs: rhs_type.clone(), + source: Source::ArrayLen, + span: op.location.span, }); - // We could check if all elements of all arrays are comptime but I am lazy - Ok(Bool(CompTime::No(Some(op.location.span)))) + Ok(Bool) } (lhs @ NamedGeneric(binding_a, _), rhs @ NamedGeneric(binding_b, _)) => { if binding_a == binding_b { - return Ok(Bool(CompTime::No(Some(op.location.span)))); + return Ok(Bool); } Err(TypeCheckError::TypeMismatchWithSource { rhs: lhs.clone(), @@ -814,16 +757,14 @@ impl<'interner> TypeChecker<'interner> { }) } (String(x_size), String(y_size)) => { - x_size.unify(y_size, op.location.span, &mut self.errors, || { - TypeCheckError::TypeMismatchWithSource { - rhs: *x_size.clone(), - lhs: *y_size.clone(), - span: op.location.span, - source: Source::StringLen, - } + self.unify(x_size, y_size, || TypeCheckError::TypeMismatchWithSource { + rhs: *x_size.clone(), + lhs: *y_size.clone(), + span: op.location.span, + source: Source::StringLen, }); - Ok(Bool(CompTime::No(Some(op.location.span)))) + Ok(Bool) } (lhs, rhs) => Err(TypeCheckError::TypeMismatchWithSource { rhs: lhs.clone(), @@ -894,12 +835,10 @@ impl<'interner> TypeChecker<'interner> { } for (param, (arg, _, arg_span)) in fn_params.iter().zip(callsite_args) { - arg.make_subtype_of(param, *arg_span, &mut self.errors, || { - TypeCheckError::TypeMismatch { - expected_typ: param.to_string(), - expr_typ: arg.to_string(), - expr_span: *arg_span, - } + self.unify(arg, param, || TypeCheckError::TypeMismatch { + expected_typ: param.to_string(), + expr_typ: arg.to_string(), + expr_span: *arg_span, }); } @@ -943,7 +882,6 @@ impl<'interner> TypeChecker<'interner> { } // Given a binary operator and another type. This method will produce the output type - // XXX: Review these rules. In particular, the interaction between integers, comptime and private/public variables fn infix_operand_type_rules( &mut self, lhs_type: &Type, @@ -962,7 +900,7 @@ impl<'interner> TypeChecker<'interner> { // Matches on TypeVariable must be first so that we follow any type // bindings. - (var @ TypeVariable(int, _), other) | (other, var @ TypeVariable(int, _)) => { + (TypeVariable(int, _), other) | (other, TypeVariable(int, _)) => { if let TypeBinding::Bound(binding) = &*int.borrow() { return self.infix_operand_type_rules(binding, op, other, span); } @@ -990,10 +928,7 @@ impl<'interner> TypeChecker<'interner> { })); } - let comptime = var.try_get_comptime(); - if other.try_bind_to_polymorphic_int(int, &comptime, true, op.location.span).is_ok() - || other == &Type::Error - { + if other.try_bind_to_polymorphic_int(int).is_ok() || other == &Type::Error { Ok(other.clone()) } else { Err(TypeCheckError::TypeMismatchWithSource { @@ -1004,10 +939,7 @@ impl<'interner> TypeChecker<'interner> { }) } } - ( - Integer(comptime_x, sign_x, bit_width_x), - Integer(comptime_y, sign_y, bit_width_y), - ) => { + (Integer(sign_x, bit_width_x), Integer(sign_y, bit_width_y)) => { if sign_x != sign_y { return Err(TypeCheckError::IntegerSignedness { sign_x: *sign_x, @@ -1027,11 +959,10 @@ impl<'interner> TypeChecker<'interner> { { Err(TypeCheckError::InvalidInfixOp { kind: "Signed integer", span }) } else { - let comptime = comptime_x.and(comptime_y, op.location.span); - Ok(Integer(comptime, *sign_x, *bit_width_x)) + Ok(Integer(*sign_x, *bit_width_x)) } } - (Integer(..), FieldElement(..)) | (FieldElement(..), Integer(..)) => { + (Integer(..), FieldElement) | (FieldElement, Integer(..)) => { Err(TypeCheckError::IntegerAndFieldBinaryOperation { span }) } (Integer(..), typ) | (typ, Integer(..)) => { @@ -1051,17 +982,14 @@ impl<'interner> TypeChecker<'interner> { (Unit, _) | (_, Unit) => Ok(Unit), // The result of two Fields is always a witness - (FieldElement(comptime_x), FieldElement(comptime_y)) => { + (FieldElement, FieldElement) => { if op.is_bitwise() { return Err(TypeCheckError::InvalidBitwiseOperationOnField { span }); } - let comptime = comptime_x.and(comptime_y, op.location.span); - Ok(FieldElement(comptime)) + Ok(FieldElement) } - (Bool(comptime_x), Bool(comptime_y)) => { - Ok(Bool(comptime_x.and(comptime_y, op.location.span))) - } + (Bool, Bool) => Ok(Bool), (lhs, rhs) => Err(TypeCheckError::TypeMismatchWithSource { rhs: lhs.clone(), @@ -1079,7 +1007,7 @@ impl<'interner> TypeChecker<'interner> { span: Span, ) -> Type { let mut unify = |expected| { - rhs_type.unify(&expected, span, &mut self.errors, || TypeCheckError::TypeMismatch { + rhs_type.unify(&expected, &mut self.errors, || TypeCheckError::TypeMismatch { expr_typ: rhs_type.to_string(), expected_typ: expected.to_string(), expr_span: span, @@ -1090,8 +1018,9 @@ impl<'interner> TypeChecker<'interner> { match op { crate::UnaryOp::Minus => { let expected = Type::polymorphic_integer(self.interner); - rhs_type.unify(&expected, span, &mut self.errors, || { - TypeCheckError::InvalidUnaryOp { kind: rhs_type.to_string(), span } + rhs_type.unify(&expected, &mut self.errors, || TypeCheckError::InvalidUnaryOp { + kind: rhs_type.to_string(), + span, }); expected } @@ -1103,7 +1032,7 @@ impl<'interner> TypeChecker<'interner> { return rhs_type; } - unify(Type::Bool(CompTime::new(self.interner))) + unify(Type::Bool) } crate::UnaryOp::MutableReference => { Type::MutableReference(Box::new(rhs_type.follow_bindings())) diff --git a/crates/noirc_frontend/src/hir/type_check/mod.rs b/crates/noirc_frontend/src/hir/type_check/mod.rs index 1883c0abf62..8768120af2f 100644 --- a/crates/noirc_frontend/src/hir/type_check/mod.rs +++ b/crates/noirc_frontend/src/hir/type_check/mod.rs @@ -4,18 +4,14 @@ //! the HIR of each function and outputs the inferred type of each HIR node into the NodeInterner, //! keyed by the ID of the node. //! -//! The algorithm for checking and inferring types itself is somewhat ad-hoc. It includes both -//! unification and subtyping, with the only difference between the two being how CompTime -//! is handled (See note on CompTime and make_subtype_of for details). Additionally, although -//! this algorithm features inference via TypeVariables, there is no generalization step as -//! all functions are required to give their full signatures. Closures are inferred but are +//! Although this algorithm features inference via TypeVariables, there is no generalization step +//! as all functions are required to give their full signatures. Closures are inferred but are //! never generalized and thus cannot be used polymorphically. mod errors; mod expr; mod stmt; pub use errors::TypeCheckError; -use noirc_errors::Span; use crate::{ node_interner::{ExprId, FuncId, NodeInterner, StmtId}, @@ -26,7 +22,6 @@ type TypeCheckFn = Box Result<(), TypeCheckError>>; pub struct TypeChecker<'interner> { delayed_type_checks: Vec, - current_function: Option, interner: &'interner mut NodeInterner, errors: Vec, } @@ -41,7 +36,7 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec Vec Vec TypeChecker<'interner> { - fn new(current_function: FuncId, interner: &'interner mut NodeInterner) -> Self { - Self { - delayed_type_checks: Vec::new(), - current_function: Some(current_function), - interner, - errors: vec![], - } + fn new(interner: &'interner mut NodeInterner) -> Self { + Self { delayed_type_checks: Vec::new(), interner, errors: vec![] } } pub fn push_delayed_type_check(&mut self, f: TypeCheckFn) { @@ -102,42 +92,30 @@ impl<'interner> TypeChecker<'interner> { } pub fn check_global(id: &StmtId, interner: &'interner mut NodeInterner) -> Vec { - let mut this = Self { - delayed_type_checks: Vec::new(), - current_function: None, - interner, - errors: vec![], - }; + let mut this = Self { delayed_type_checks: Vec::new(), interner, errors: vec![] }; this.check_statement(id); this.errors } - fn is_unconstrained(&self) -> bool { - self.current_function.map_or(false, |current_function| { - self.interner.function_meta(¤t_function).is_unconstrained - }) - } - /// Wrapper of Type::unify using self.errors fn unify( &mut self, actual: &Type, expected: &Type, - span: Span, make_error: impl FnOnce() -> TypeCheckError, ) { - actual.unify(expected, span, &mut self.errors, make_error); + actual.unify(expected, &mut self.errors, make_error); } - /// Wrapper of Type::make_subtype_of using self.errors - fn make_subtype_of( + /// Wrapper of Type::unify_with_coercions using self.errors + fn unify_with_coercions( &mut self, actual: &Type, expected: &Type, expression: ExprId, make_error: impl FnOnce() -> TypeCheckError, ) { - actual.make_subtype_with_coercions( + actual.unify_with_coercions( expected, expression, self.interner, @@ -220,7 +198,7 @@ mod test { // Create let statement let let_stmt = HirLetStatement { pattern: Identifier(z), - r#type: Type::FieldElement(crate::CompTime::No(None)), + r#type: Type::FieldElement, expression: expr_id, }; let stmt_id = interner.push_stmt(HirStatement::Let(let_stmt)); @@ -247,13 +225,13 @@ mod test { is_internal: None, is_unconstrained: false, typ: Type::Function( - vec![Type::field(None), Type::field(None)], + vec![Type::FieldElement, Type::FieldElement], Box::new(Type::Unit), Box::new(Type::Unit), ), parameters: vec![ - Param(Identifier(x), Type::field(None), noirc_abi::AbiVisibility::Private), - Param(Identifier(y), Type::field(None), noirc_abi::AbiVisibility::Private), + Param(Identifier(x), Type::FieldElement, noirc_abi::AbiVisibility::Private), + Param(Identifier(y), Type::FieldElement, noirc_abi::AbiVisibility::Private), ] .into(), return_visibility: noirc_abi::AbiVisibility::Private, diff --git a/crates/noirc_frontend/src/hir/type_check/stmt.rs b/crates/noirc_frontend/src/hir/type_check/stmt.rs index 3130a8616de..b3a672cb05b 100644 --- a/crates/noirc_frontend/src/hir/type_check/stmt.rs +++ b/crates/noirc_frontend/src/hir/type_check/stmt.rs @@ -6,7 +6,6 @@ use crate::hir_def::stmt::{ }; use crate::hir_def::types::Type; use crate::node_interner::{DefinitionId, ExprId, StmtId}; -use crate::CompTime; use super::errors::{Source, TypeCheckError}; use super::TypeChecker; @@ -75,7 +74,7 @@ impl<'interner> TypeChecker<'interner> { } }, HirPattern::Struct(struct_type, fields, span) => { - self.unify(struct_type, &typ, *span, || TypeCheckError::TypeMismatch { + self.unify(struct_type, &typ, || TypeCheckError::TypeMismatch { expected_typ: typ.to_string(), expr_typ: struct_type.to_string(), expr_span: *span, @@ -108,7 +107,7 @@ impl<'interner> TypeChecker<'interner> { }); let span = self.interner.expr_span(&assign_stmt.expression); - self.make_subtype_of(&expr_type, &lvalue_type, assign_stmt.expression, || { + self.unify_with_coercions(&expr_type, &lvalue_type, assign_stmt.expression, || { TypeCheckError::TypeMismatchWithSource { rhs: expr_type.clone(), lhs: lvalue_type.clone(), @@ -178,7 +177,6 @@ impl<'interner> TypeChecker<'interner> { index_type.unify( &Type::polymorphic_integer(self.interner), - expr_span, &mut self.errors, || TypeCheckError::TypeMismatch { expected_typ: "an integer".to_owned(), @@ -212,12 +210,10 @@ impl<'interner> TypeChecker<'interner> { let element_type = Type::type_variable(self.interner.next_type_variable_id()); let expected_type = Type::MutableReference(Box::new(element_type.clone())); - reference_type.unify(&expected_type, assign_span, &mut self.errors, || { - TypeCheckError::TypeMismatch { - expected_typ: expected_type.to_string(), - expr_typ: reference_type.to_string(), - expr_span: assign_span, - } + self.unify(&reference_type, &expected_type, || TypeCheckError::TypeMismatch { + expected_typ: expected_type.to_string(), + expr_typ: reference_type.to_string(), + expr_span: assign_span, }); (element_type.clone(), HirLValue::Dereference { lvalue, element_type }) @@ -226,9 +222,7 @@ impl<'interner> TypeChecker<'interner> { } fn check_let_stmt(&mut self, let_stmt: HirLetStatement) { - let mut resolved_type = self.check_declaration(let_stmt.expression, let_stmt.r#type); - - resolved_type.set_comp_time_span(self.interner.expr_span(&let_stmt.expression)); + let resolved_type = self.check_declaration(let_stmt.expression, let_stmt.r#type); // Set the type of the pattern to be equal to the annotated type self.bind_pattern(&let_stmt.pattern, resolved_type); @@ -238,10 +232,9 @@ impl<'interner> TypeChecker<'interner> { let expr_type = self.check_expression(&stmt.0); let expr_span = self.interner.expr_span(&stmt.0); - let bool_type = Type::Bool(CompTime::new(self.interner)); - self.unify(&expr_type, &bool_type, expr_span, || TypeCheckError::TypeMismatch { + self.unify(&expr_type, &Type::Bool, || TypeCheckError::TypeMismatch { expr_typ: expr_type.to_string(), - expected_typ: Type::Bool(CompTime::No(None)).to_string(), + expected_typ: Type::Bool.to_string(), expr_span, }); } @@ -259,7 +252,7 @@ impl<'interner> TypeChecker<'interner> { // Now check if LHS is the same type as the RHS // Importantly, we do not coerce any types implicitly let expr_span = self.interner.expr_span(&rhs_expr); - self.make_subtype_of(&expr_type, &annotated_type, rhs_expr, || { + self.unify_with_coercions(&expr_type, &annotated_type, rhs_expr, || { TypeCheckError::TypeMismatch { expected_typ: annotated_type.to_string(), expr_typ: expr_type.to_string(), diff --git a/crates/noirc_frontend/src/hir_def/types.rs b/crates/noirc_frontend/src/hir_def/types.rs index 587001bfafc..d938421cb0e 100644 --- a/crates/noirc_frontend/src/hir_def/types.rs +++ b/crates/noirc_frontend/src/hir_def/types.rs @@ -1,5 +1,4 @@ use std::{ - borrow::Cow, cell::RefCell, collections::{BTreeSet, HashMap}, rc::Rc, @@ -19,21 +18,19 @@ use super::expr::{HirCallExpression, HirExpression, HirIdent}; #[derive(Debug, PartialEq, Eq, Clone, Hash)] pub enum Type { - /// A primitive Field type, and whether or not it is known at compile-time. - FieldElement(CompTime), + /// A primitive Field type + FieldElement, /// Array(N, E) is an array of N elements of type E. It is expected that N /// is either a type variable of some kind or a Type::Constant. Array(Box, Box), - /// A primitive integer type with the given sign, bit count, and whether it is known at compile-time. - /// E.g. `u32` would be `Integer(CompTime::No(None), Unsigned, 32)` - Integer(CompTime, Signedness, u32), + /// A primitive integer type with the given sign and bit count. + /// E.g. `u32` would be `Integer(Unsigned, 32)` + Integer(Signedness, u32), - /// The primitive `bool` type. Like other primitive types, whether booleans are known at CompTime - /// is also tracked. Unlike the other primitives however, it isn't as useful since it is - /// primarily only used when converting between a bool and an integer type for indexing arrays. - Bool(CompTime), + /// The primitive `bool` type. + Bool, /// String(N) is an array of characters of length N. It is expected that N /// is either a type variable of some kind or a Type::Constant. @@ -361,7 +358,7 @@ pub enum TypeVariableKind { /// This is the type of undecorated integer literals like `46`. Typing them in this way /// allows them to be polymorphic over the actual integer/field type used without requiring /// type annotations on each integer literal. - IntegerOrField(CompTime), + IntegerOrField, /// A potentially constant array size. This will only bind to itself, Type::NotConstant, or /// Type::Constant(n) with a matching size. This defaults to Type::Constant(n) if still unbound @@ -405,225 +402,9 @@ impl TypeBinding { #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub struct TypeVariableId(pub usize); -/// Noir's type system keeps track of whether or not every primitive type's value -/// is known at compile-time. This is exposed through users through the `comptime` -/// keyword in noir which can be prefixed before primitive types. A usage like -/// `t: comptime Field` would correspond to a Field type with a CompTime::Yes(None) -/// variant of this enum -/// -/// Note that whether or not a variable is comptime can also be inferred based on its use. -/// A value passed to a function that expects a `comptime Field` must be CompTime::Yes, -/// likewise a parameter of the current function that is just a `Field` can only be CompTime::No. -/// There is also the case of integer literals which are typed as CompTime::Maybe. These are -/// polymorphically comptime because they can be used in both contexts. -#[derive(Debug, Clone, Eq)] -pub enum CompTime { - // Yes and No variants have optional spans representing the location in the source code - // which caused them to be compile time. - Yes(Option), - No(Option), - - /// Maybe has an id and shared inner reference that can be rebound later to - /// another specific CompTime variant. - Maybe(TypeVariableId, Shared>), -} - -impl std::hash::Hash for CompTime { - fn hash(&self, state: &mut H) { - core::mem::discriminant(self).hash(state); - - if let CompTime::Maybe(id, binding) = self { - if let Some(is_comp_time) = &*binding.borrow() { - is_comp_time.hash(state); - } else { - id.hash(state); - } - } - } -} - -impl PartialEq for CompTime { - fn eq(&self, other: &Self) -> bool { - match (self, other) { - (CompTime::Maybe(id1, binding1), CompTime::Maybe(id2, binding2)) => { - if let Some(new_self) = &*binding1.borrow() { - return new_self == other; - } - if let Some(new_other) = &*binding2.borrow() { - return self == new_other; - } - id1 == id2 - } - (CompTime::Yes(_), CompTime::Yes(_)) | (CompTime::No(_), CompTime::No(_)) => true, - _ => false, - } - } -} - -/// Internal enum for `unify` to remember the type context of each span -/// to provide better error messages -#[derive(Debug)] -pub enum SpanKind { - CompTime(Span), - NotCompTime(Span), - None, -} - -impl CompTime { - pub fn new(interner: &mut NodeInterner) -> Self { - let id = interner.next_type_variable_id(); - Self::Maybe(id, Shared::new(None)) - } - - /// Set the Span on this CompTime (if it has one) to keep track of - /// when it was last changed to give better error messages. - fn set_span(&mut self, new_span: Span) { - match self { - CompTime::Yes(span) | CompTime::No(span) => *span = Some(new_span), - CompTime::Maybe(_, binding) => { - if let Some(binding) = &mut *binding.borrow_mut() { - binding.set_span(new_span); - } - } - } - } - - /// Try to unify these two CompTime constraints. - pub fn unify(&self, other: &Self, span: Span) -> Result<(), SpanKind> { - match (self, other) { - (CompTime::Yes(_), CompTime::Yes(_)) | (CompTime::No(_), CompTime::No(_)) => Ok(()), - - (CompTime::Yes(y), CompTime::No(n)) | (CompTime::No(n), CompTime::Yes(y)) => { - Err(match (y, n) { - (_, Some(span)) => SpanKind::NotCompTime(*span), - (Some(span), _) => SpanKind::CompTime(*span), - _ => SpanKind::None, - }) - } - - (CompTime::Maybe(_, binding), other) | (other, CompTime::Maybe(_, binding)) - if binding.borrow().is_some() => - { - let binding = &*binding.borrow(); - binding.as_ref().unwrap().unify(other, span) - } - - (CompTime::Maybe(id1, _), CompTime::Maybe(id2, _)) if id1 == id2 => Ok(()), - - // Both are unbound and do not refer to each other, arbitrarily set one equal to the other - (CompTime::Maybe(_, binding), other) | (other, CompTime::Maybe(_, binding)) => { - let mut clone = other.clone(); - clone.set_span(span); - *binding.borrow_mut() = Some(clone); - Ok(()) - } - } - } - - /// Try to unify these two CompTime constraints. - pub fn is_subtype_of(&self, other: &Self, span: Span) -> Result<(), SpanKind> { - match (self, other) { - (CompTime::Yes(_), CompTime::Yes(_)) - | (CompTime::No(_), CompTime::No(_)) - - // This is one of the only 2 differing cases between this and CompTime::unify - | (CompTime::Yes(_), CompTime::No(_)) => Ok(()), - - (CompTime::No(n), CompTime::Yes(y)) => { - Err(match (y, n) { - (_, Some(span)) => SpanKind::NotCompTime(*span), - (Some(span), _) => SpanKind::CompTime(*span), - _ => SpanKind::None, - }) - } - - (CompTime::Maybe(_, binding), other) if binding.borrow().is_some() => { - let binding = &*binding.borrow(); - binding.as_ref().unwrap().is_subtype_of(other, span) - } - - (other, CompTime::Maybe(_, binding)) if binding.borrow().is_some() => { - let binding = &*binding.borrow(); - other.is_subtype_of(binding.as_ref().unwrap(), span) - } - - (CompTime::Maybe(id1, _), CompTime::Maybe(id2, _)) if id1 == id2 => Ok(()), - - // This is the other differing case between this and CompTime::unify. - // If this is polymorphically comptime, don't force it to be non-comptime because it is - // passed as an argument to a function expecting a non-comptime parameter. - (CompTime::Maybe(_, binding), CompTime::No(_)) if binding.borrow().is_none() => Ok(()), - - (CompTime::Maybe(_, binding), other) => { - let mut clone = other.clone(); - clone.set_span(span); - *binding.borrow_mut() = Some(clone); - Ok(()) - } - (other, CompTime::Maybe(_, binding)) => { - let mut clone = other.clone(); - clone.set_span(span); - *binding.borrow_mut() = Some(clone); - Ok(()) - } - } - } - - /// Combine these two CompTimes together, returning - /// - CompTime::Yes if both are Yes, - /// - CompTime::No if either are No, - /// - or if both are Maybe, unify them both and return the lhs. - pub fn and(&self, other: &Self, span: Span) -> Self { - match (self, other) { - (CompTime::Yes(_), CompTime::Yes(_)) => CompTime::Yes(Some(span)), - - (CompTime::No(_), CompTime::No(_)) - | (CompTime::Yes(_), CompTime::No(_)) - | (CompTime::No(_), CompTime::Yes(_)) => CompTime::No(Some(span)), - - (CompTime::Maybe(_, binding), other) | (other, CompTime::Maybe(_, binding)) - if binding.borrow().is_some() => - { - let binding = &*binding.borrow(); - binding.as_ref().unwrap().and(other, span) - } - - (CompTime::Maybe(id1, _), CompTime::Maybe(id2, _)) if id1 == id2 => self.clone(), - - (CompTime::Maybe(_, binding), other) | (other, CompTime::Maybe(_, binding)) => { - let mut clone = other.clone(); - clone.set_span(span); - *binding.borrow_mut() = Some(clone); - other.clone() - } - } - } - - pub fn is_comp_time(&self) -> bool { - match self { - CompTime::Yes(_) => true, - CompTime::No(_) => false, - CompTime::Maybe(_, binding) => { - if let Some(binding) = &*binding.borrow() { - return binding.is_comp_time(); - } - true - } - } - } -} - impl Type { - pub fn field(span: Option) -> Type { - Type::FieldElement(CompTime::No(span)) - } - - pub fn comp_time(span: Option) -> Type { - Type::FieldElement(CompTime::Yes(span)) - } - - pub fn default_int_type(span: Option) -> Type { - Type::field(span) + pub fn default_int_type() -> Type { + Type::FieldElement } pub fn type_variable(id: TypeVariableId) -> Type { @@ -640,7 +421,7 @@ impl Type { pub fn polymorphic_integer(interner: &mut NodeInterner) -> Type { let id = interner.next_type_variable_id(); - let kind = TypeVariableKind::IntegerOrField(CompTime::new(interner)); + let kind = TypeVariableKind::IntegerOrField; Type::TypeVariable(Shared::new(TypeBinding::Unbound(id)), kind) } @@ -659,11 +440,11 @@ impl Type { } pub fn is_field(&self) -> bool { - matches!(self.follow_bindings(), Type::FieldElement(_)) + matches!(self.follow_bindings(), Type::FieldElement) } pub fn is_signed(&self) -> bool { - matches!(self.follow_bindings(), Type::Integer(_, Signedness::Signed, _)) + matches!(self.follow_bindings(), Type::Integer(Signedness::Signed, _)) } fn contains_numeric_typevar(&self, target_id: TypeVariableId) -> bool { @@ -682,9 +463,9 @@ impl Type { }; match self { - Type::FieldElement(_) - | Type::Integer(_, _, _) - | Type::Bool(_) + Type::FieldElement + | Type::Integer(_, _) + | Type::Bool | Type::Unit | Type::Error | Type::TypeVariable(_, _) @@ -722,25 +503,13 @@ impl Type { } } } - - pub(crate) fn try_get_comptime(&self) -> Cow { - match self { - Type::FieldElement(comptime) - | Type::Integer(comptime, _, _) - | Type::Bool(comptime) - | Type::TypeVariable(_, TypeVariableKind::IntegerOrField(comptime)) => { - Cow::Borrowed(comptime) - } - _ => Cow::Owned(CompTime::No(None)), - } - } } impl std::fmt::Display for Type { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - Type::FieldElement(comp_time) => { - write!(f, "{comp_time}Field") + Type::FieldElement => { + write!(f, "Field") } Type::Array(len, typ) => { if matches!(len.follow_bindings(), Type::NotConstant) { @@ -749,12 +518,12 @@ impl std::fmt::Display for Type { write!(f, "[{typ}; {len}]") } } - Type::Integer(comp_time, sign, num_bits) => match sign { - Signedness::Signed => write!(f, "{comp_time}i{num_bits}"), - Signedness::Unsigned => write!(f, "{comp_time}u{num_bits}"), + Type::Integer(sign, num_bits) => match sign { + Signedness::Signed => write!(f, "i{num_bits}"), + Signedness::Unsigned => write!(f, "u{num_bits}"), }, Type::TypeVariable(id, TypeVariableKind::Normal) => write!(f, "{}", id.borrow()), - Type::TypeVariable(binding, TypeVariableKind::IntegerOrField(_)) => { + Type::TypeVariable(binding, TypeVariableKind::IntegerOrField) => { if let TypeBinding::Unbound(_) = &*binding.borrow() { // Show a Field by default if this TypeVariableKind::IntegerOrField is unbound, since that is // what they bind to by default anyway. It is less confusing than displaying it @@ -784,7 +553,7 @@ impl std::fmt::Display for Type { let elements = vecmap(elements, ToString::to_string); write!(f, "({})", elements.join(", ")) } - Type::Bool(comp_time) => write!(f, "{comp_time}bool"), + Type::Bool => write!(f, "bool"), Type::String(len) => write!(f, "str<{len}>"), Type::FmtString(len, elements) => { write!(f, "fmtstr<{len}, {elements}>") @@ -846,60 +615,16 @@ impl std::fmt::Display for TypeBinding { } } -impl std::fmt::Display for CompTime { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - CompTime::Yes(_) => write!(f, "comptime "), - CompTime::No(_) => Ok(()), - CompTime::Maybe(_, binding) => match &*binding.borrow() { - Some(binding) => binding.fmt(f), - None => write!(f, "comptime "), - }, - } - } -} +pub struct UnificationError; impl Type { - /// Mutate the span for the `CompTime` enum to track where a type is required to be `comptime` - /// for error messages that show both the erroring call site and the call site before - /// which required the variable to be comptime or non-comptime. - pub fn set_comp_time_span(&mut self, new_span: Span) { - match self { - Type::FieldElement(comptime) | Type::Integer(comptime, _, _) => { - comptime.set_span(new_span); - } - Type::TypeVariable(binding, TypeVariableKind::IntegerOrField(span)) => { - if let TypeBinding::Bound(binding) = &mut *binding.borrow_mut() { - return binding.set_comp_time_span(new_span); - } - span.set_span(new_span); - } - _ => (), - } - } - - pub fn set_comp_time(&mut self, new_comptime: CompTime) { - match self { - Type::FieldElement(comptime) | Type::Integer(comptime, _, _) => { - *comptime = new_comptime; - } - Type::TypeVariable(binding, TypeVariableKind::IntegerOrField(comptime)) => { - if let TypeBinding::Bound(binding) = &mut *binding.borrow_mut() { - return binding.set_comp_time(new_comptime); - } - *comptime = new_comptime; - } - _ => (), - } - } - /// Try to bind a MaybeConstant variable to self, succeeding if self is a Constant, /// MaybeConstant, or type variable. pub fn try_bind_to_maybe_constant( &self, var: &TypeVariable, target_length: u64, - ) -> Result<(), SpanKind> { + ) -> Result<(), UnificationError> { let target_id = match &*var.borrow() { TypeBinding::Bound(_) => unreachable!(), TypeBinding::Unbound(id) => *id, @@ -939,91 +664,64 @@ impl Type { *binding.borrow_mut() = TypeBinding::Bound(clone); Ok(()) } - TypeVariableKind::Constant(_) | TypeVariableKind::IntegerOrField(_) => { - Err(SpanKind::None) + TypeVariableKind::Constant(_) | TypeVariableKind::IntegerOrField => { + Err(UnificationError) } }, } } - _ => Err(SpanKind::None), + _ => Err(UnificationError), } } /// Try to bind a PolymorphicInt variable to self, succeeding if self is an integer, field, - /// other PolymorphicInt type, or type variable. If use_subtype is true, the CompTime fields - /// of each will be checked via sub-typing rather than unification. - pub fn try_bind_to_polymorphic_int( - &self, - var: &TypeVariable, - var_comp_time: &CompTime, - use_subtype: bool, - span: Span, - ) -> Result<(), SpanKind> { + /// other PolymorphicInt type, or type variable. + pub fn try_bind_to_polymorphic_int(&self, var: &TypeVariable) -> Result<(), UnificationError> { let target_id = match &*var.borrow() { TypeBinding::Bound(_) => unreachable!(), TypeBinding::Unbound(id) => *id, }; - let bind = |int_comp_time: &CompTime| { - let mut clone = self.clone(); - let mut new_comp_time = var_comp_time.clone(); - new_comp_time.set_span(span); - clone.set_comp_time(new_comp_time); - - *var.borrow_mut() = TypeBinding::Bound(clone); - - if use_subtype { - var_comp_time.is_subtype_of(int_comp_time, span) - } else { - var_comp_time.unify(int_comp_time, span) - } - }; - match self { - Type::FieldElement(int_comp_time, ..) | Type::Integer(int_comp_time, ..) => { - bind(int_comp_time) + Type::FieldElement | Type::Integer(..) => { + *var.borrow_mut() = TypeBinding::Bound(self.clone()); + Ok(()) } - Type::TypeVariable(self_var, TypeVariableKind::IntegerOrField(int_comp_time)) => { + Type::TypeVariable(self_var, TypeVariableKind::IntegerOrField) => { let borrow = self_var.borrow(); match &*borrow { - TypeBinding::Bound(typ) => { - typ.try_bind_to_polymorphic_int(var, var_comp_time, use_subtype, span) - } + TypeBinding::Bound(typ) => typ.try_bind_to_polymorphic_int(var), // Avoid infinitely recursive bindings TypeBinding::Unbound(id) if *id == target_id => Ok(()), TypeBinding::Unbound(_) => { drop(borrow); - bind(int_comp_time) + *var.borrow_mut() = TypeBinding::Bound(self.clone()); + Ok(()) } } } Type::TypeVariable(binding, TypeVariableKind::Normal) => { let borrow = binding.borrow(); match &*borrow { - TypeBinding::Bound(typ) => { - typ.try_bind_to_polymorphic_int(var, var_comp_time, use_subtype, span) - } + TypeBinding::Bound(typ) => typ.try_bind_to_polymorphic_int(var), // Avoid infinitely recursive bindings TypeBinding::Unbound(id) if *id == target_id => Ok(()), TypeBinding::Unbound(_) => { drop(borrow); // PolymorphicInt is more specific than TypeVariable so we bind the type // variable to PolymorphicInt instead. - let mut clone = Type::TypeVariable( - var.clone(), - TypeVariableKind::IntegerOrField(var_comp_time.clone()), - ); - clone.set_comp_time_span(span); + let clone = + Type::TypeVariable(var.clone(), TypeVariableKind::IntegerOrField); *binding.borrow_mut() = TypeBinding::Bound(clone); Ok(()) } } } - _ => Err(SpanKind::None), + _ => Err(UnificationError), } } - pub fn try_bind_to(&self, var: &TypeVariable) -> Result<(), SpanKind> { + pub fn try_bind_to(&self, var: &TypeVariable) -> Result<(), UnificationError> { let target_id = match &*var.borrow() { TypeBinding::Bound(_) => unreachable!(), TypeBinding::Unbound(id) => *id, @@ -1041,7 +739,7 @@ impl Type { // Check if the target id occurs within self before binding. Otherwise this could // cause infinitely recursive types if self.occurs(target_id) { - Err(SpanKind::None) + Err(UnificationError) } else { *var.borrow_mut() = TypeBinding::Bound(self.clone()); Ok(()) @@ -1055,20 +753,6 @@ impl Type { } } - fn is_comp_time(&self) -> bool { - match self { - Type::FieldElement(comptime) => comptime.is_comp_time(), - Type::Integer(comptime, ..) => comptime.is_comp_time(), - Type::TypeVariable(binding, TypeVariableKind::IntegerOrField(comptime)) => { - if let TypeBinding::Bound(binding) = &*binding.borrow() { - return binding.is_comp_time(); - } - comptime.is_comp_time() - } - _ => false, - } - } - /// Try to unify this type with another, setting any type variables found /// equal to the other type in the process. Unification is more strict /// than sub-typing but less strict than Eq. Returns true if the unification @@ -1077,58 +761,38 @@ impl Type { pub fn unify( &self, expected: &Type, - span: Span, errors: &mut Vec, make_error: impl FnOnce() -> TypeCheckError, ) { - if let Err(err_span) = self.try_unify(expected, span) { - Self::issue_errors(expected, err_span, errors, make_error); - } - } - - fn issue_errors( - expected: &Type, - err_span: SpanKind, - errors: &mut Vec, - make_error: impl FnOnce() -> TypeCheckError, - ) { - errors.push(make_error()); - - match (expected.is_comp_time(), err_span) { - (true, SpanKind::NotCompTime(span)) => { - errors.push(TypeCheckError::NotCompTime { span }); - } - (false, SpanKind::CompTime(span)) => { - errors.push(TypeCheckError::CompTime { span }); - } - _ => (), + if let Err(UnificationError) = self.try_unify(expected) { + errors.push(make_error()); } } /// `try_unify` is a bit of a misnomer since although errors are not committed, /// any unified bindings are on success. - fn try_unify(&self, other: &Type, span: Span) -> Result<(), SpanKind> { + fn try_unify(&self, other: &Type) -> Result<(), UnificationError> { use Type::*; use TypeVariableKind as Kind; match (self, other) { (Error, _) | (_, Error) => Ok(()), - (TypeVariable(binding, Kind::IntegerOrField(comptime)), other) - | (other, TypeVariable(binding, Kind::IntegerOrField(comptime))) => { + (TypeVariable(binding, Kind::IntegerOrField), other) + | (other, TypeVariable(binding, Kind::IntegerOrField)) => { // If it is already bound, unify against what it is bound to if let TypeBinding::Bound(link) = &*binding.borrow() { - return link.try_unify(other, span); + return link.try_unify(other); } // Otherwise, check it is unified against an integer and bind it - other.try_bind_to_polymorphic_int(binding, comptime, false, span) + other.try_bind_to_polymorphic_int(binding) } (TypeVariable(binding, Kind::Normal), other) | (other, TypeVariable(binding, Kind::Normal)) => { if let TypeBinding::Bound(link) = &*binding.borrow() { - return link.try_unify(other, span); + return link.try_unify(other); } other.try_bind_to(binding) @@ -1137,30 +801,30 @@ impl Type { (TypeVariable(binding, Kind::Constant(length)), other) | (other, TypeVariable(binding, Kind::Constant(length))) => { if let TypeBinding::Bound(link) = &*binding.borrow() { - return link.try_unify(other, span); + return link.try_unify(other); } other.try_bind_to_maybe_constant(binding, *length) } (Array(len_a, elem_a), Array(len_b, elem_b)) => { - len_a.try_unify(len_b, span)?; - elem_a.try_unify(elem_b, span) + len_a.try_unify(len_b)?; + elem_a.try_unify(elem_b) } - (String(len_a), String(len_b)) => len_a.try_unify(len_b, span), + (String(len_a), String(len_b)) => len_a.try_unify(len_b), (FmtString(len_a, elements_a), FmtString(len_b, elements_b)) => { - len_a.try_unify(len_b, span)?; - elements_a.try_unify(elements_b, span) + len_a.try_unify(len_b)?; + elements_a.try_unify(elements_b) } (Tuple(elements_a), Tuple(elements_b)) => { if elements_a.len() != elements_b.len() { - Err(SpanKind::None) + Err(UnificationError) } else { for (a, b) in elements_a.iter().zip(elements_b) { - a.try_unify(b, span)?; + a.try_unify(b)?; } Ok(()) } @@ -1172,28 +836,14 @@ impl Type { (Struct(fields_a, args_a), Struct(fields_b, args_b)) => { if fields_a == fields_b { for (a, b) in args_a.iter().zip(args_b) { - a.try_unify(b, span)?; + a.try_unify(b)?; } Ok(()) } else { - Err(SpanKind::None) + Err(UnificationError) } } - (FieldElement(comptime_a), FieldElement(comptime_b)) => { - comptime_a.unify(comptime_b, span) - } - - (Integer(comptime_a, signed_a, bits_a), Integer(comptime_b, signed_b, bits_b)) => { - if signed_a == signed_b && bits_a == bits_b { - comptime_a.unify(comptime_b, span) - } else { - Err(SpanKind::None) - } - } - - (Bool(comptime_a), Bool(comptime_b)) => comptime_a.unify(comptime_b, span), - (NamedGeneric(binding_a, name_a), NamedGeneric(binding_b, name_b)) => { // Ensure NamedGenerics are never bound during type checking assert!(binding_a.borrow().is_unbound()); @@ -1202,56 +852,41 @@ impl Type { if name_a == name_b { Ok(()) } else { - Err(SpanKind::None) + Err(UnificationError) } } (Function(params_a, ret_a, env_a), Function(params_b, ret_b, env_b)) => { if params_a.len() == params_b.len() { for (a, b) in params_a.iter().zip(params_b.iter()) { - a.try_unify(b, span)?; + a.try_unify(b)?; } - env_a.try_unify(env_b, span)?; - - ret_b.try_unify(ret_a, span) + env_a.try_unify(env_b)?; + ret_b.try_unify(ret_a) } else { - Err(SpanKind::None) + Err(UnificationError) } } - (MutableReference(elem_a), MutableReference(elem_b)) => elem_a.try_unify(elem_b, span), + (MutableReference(elem_a), MutableReference(elem_b)) => elem_a.try_unify(elem_b), (other_a, other_b) => { if other_a == other_b { Ok(()) } else { - Err(SpanKind::None) + Err(UnificationError) } } } } - /// The `subtype` term here is somewhat loose, the only sub-typing relations remaining - /// have to do with CompTime tracking. - pub fn make_subtype_of( - &self, - expected: &Type, - span: Span, - errors: &mut Vec, - make_error: impl FnOnce() -> TypeCheckError, - ) { - if let Err(err_span) = self.is_subtype_of(expected, span) { - Self::issue_errors(expected, err_span, errors, make_error); - } - } - /// Similar to `make_subtype_of` but if the check fails this will attempt to coerce the /// argument to the target type. When this happens, the given expression is wrapped in /// a new expression to convert its type. E.g. `array` -> `array.as_slice()` /// /// Currently the only type coercion in Noir is `[T; N]` into `[T]` via `.as_slice()`. - pub fn make_subtype_with_coercions( + pub fn unify_with_coercions( &self, expected: &Type, expression: ExprId, @@ -1259,10 +894,9 @@ impl Type { errors: &mut Vec, make_error: impl FnOnce() -> TypeCheckError, ) { - let span = interner.expr_span(&expression); - if let Err(err_span) = self.is_subtype_of(expected, span) { - if !self.try_array_to_slice_coercion(expected, expression, span, interner) { - Self::issue_errors(expected, err_span, errors, make_error); + if let Err(UnificationError) = self.try_unify(expected) { + if !self.try_array_to_slice_coercion(expected, expression, interner) { + errors.push(make_error()); } } } @@ -1273,7 +907,6 @@ impl Type { &self, target: &Type, expression: ExprId, - span: Span, interner: &mut NodeInterner, ) -> bool { let this = self.follow_bindings(); @@ -1287,7 +920,7 @@ impl Type { if matches!(size1, Type::Constant(_)) && matches!(size2, Type::NotConstant) { // Still have to ensure the element types match. // Don't need to issue an error here if not, it will be done in make_subtype_of_with_coercions - if element1.is_subtype_of(element2, span).is_ok() { + if element1.try_unify(element2).is_ok() { convert_array_expression_to_slice(expression, this, target, interner); return true; } @@ -1296,166 +929,6 @@ impl Type { false } - /// Checks if self is a subtype of `other`. Returns Ok(()) if it is and Err(_) if not. - /// Note that this function may permanently bind type variables regardless of whether it - /// returned Ok or Err. - pub fn is_subtype_of(&self, other: &Type, span: Span) -> Result<(), SpanKind> { - use Type::*; - match (self, other) { - (Error, _) | (_, Error) => Ok(()), - - (TypeVariable(binding, TypeVariableKind::IntegerOrField(comptime)), other) => { - if let TypeBinding::Bound(link) = &*binding.borrow() { - return link.is_subtype_of(other, span); - } - - // Otherwise, check it is unified against an integer and bind it - other.try_bind_to_polymorphic_int(binding, comptime, true, span) - } - // These needs to be a separate case to keep the argument order of is_subtype_of - (other, TypeVariable(binding, TypeVariableKind::IntegerOrField(comptime))) => { - if let TypeBinding::Bound(link) = &*binding.borrow() { - return other.is_subtype_of(link, span); - } - - // use_subtype is false here since we have other <: PolymorphicInt - // while the flag expects PolymorphicInt <: other - other.try_bind_to_polymorphic_int(binding, comptime, false, span) - } - - (TypeVariable(binding, TypeVariableKind::Normal), other) => { - if let TypeBinding::Bound(link) = &*binding.borrow() { - return link.is_subtype_of(other, span); - } - - other.try_bind_to(binding) - } - (other, TypeVariable(binding, TypeVariableKind::Normal)) => { - if let TypeBinding::Bound(link) = &*binding.borrow() { - return other.is_subtype_of(link, span); - } - - other.try_bind_to(binding) - } - - (TypeVariable(binding, TypeVariableKind::Constant(length)), other) => { - if let TypeBinding::Bound(link) = &*binding.borrow() { - return link.is_subtype_of(other, span); - } - - other.try_bind_to_maybe_constant(binding, *length) - } - (other, TypeVariable(binding, TypeVariableKind::Constant(length))) => { - if let TypeBinding::Bound(link) = &*binding.borrow() { - return other.is_subtype_of(link, span); - } - - other.try_bind_to_maybe_constant(binding, *length) - } - - (Array(len_a, elem_a), Array(len_b, elem_b)) => { - len_a.is_subtype_of(len_b, span)?; - elem_a.is_subtype_of(elem_b, span) - } - - (String(len_a), String(len_b)) => len_a.is_subtype_of(len_b, span), - - (FmtString(len_a, elements_a), FmtString(len_b, elements_b)) => { - len_a.is_subtype_of(len_b, span)?; - elements_a.is_subtype_of(elements_b, span) - } - - (Tuple(elements_a), Tuple(elements_b)) => { - if elements_a.len() != elements_b.len() { - Err(SpanKind::None) - } else { - for (a, b) in elements_a.iter().zip(elements_b) { - a.is_subtype_of(b, span)?; - } - Ok(()) - } - } - - // No recursive try_unify call needed for struct fields, we just - // check the struct ids match. - (Struct(struct_a, args_a), Struct(struct_b, args_b)) => { - if struct_a == struct_b && args_a.len() == args_b.len() { - for (a, b) in args_a.iter().zip(args_b) { - a.is_subtype_of(b, span)?; - } - Ok(()) - } else { - Err(SpanKind::None) - } - } - - (FieldElement(comptime_a), FieldElement(comptime_b)) => { - comptime_a.is_subtype_of(comptime_b, span) - } - - (Integer(comptime_a, signed_a, bits_a), Integer(comptime_b, signed_b, bits_b)) => { - if signed_a == signed_b && bits_a == bits_b { - comptime_a.is_subtype_of(comptime_b, span) - } else { - Err(SpanKind::None) - } - } - - (Bool(comptime_a), Bool(comptime_b)) => comptime_a.is_subtype_of(comptime_b, span), - - (NamedGeneric(binding_a, name_a), NamedGeneric(binding_b, name_b)) => { - // Ensure NamedGenerics are never bound during type checking - assert!(binding_a.borrow().is_unbound()); - assert!(binding_b.borrow().is_unbound()); - - if name_a == name_b { - Ok(()) - } else { - Err(SpanKind::None) - } - } - - (Function(params_a, ret_a, env_a), Function(params_b, ret_b, env_b)) => { - if params_a.len() == params_b.len() { - for (a, b) in params_a.iter().zip(params_b) { - a.is_subtype_of(b, span)?; - } - - env_a.is_subtype_of(env_b, span)?; - - // return types are contravariant, so this must be ret_b <: ret_a instead of the reverse - ret_b.is_subtype_of(ret_a, span) - } else { - Err(SpanKind::None) - } - } - - // `T <: U => &mut T <: &mut U` would be unsound(*), so mutable - // references are never subtypes of each other. - // - // (*) Consider: - // ``` - // // Assume Dog <: Animal and Cat <: Animal - // let x: &mut Dog = ...; - // - // fn set_to_cat(y: &mut Animal) { - // *y = Cat; - // } - // - // set_to_cat(x); // uh-oh: x: Dog, yet it now holds a Cat - // ``` - (MutableReference(elem_a), MutableReference(elem_b)) => elem_a.try_unify(elem_b, span), - - (other_a, other_b) => { - if other_a == other_b { - Ok(()) - } else { - Err(SpanKind::None) - } - } - } - } - /// If this type is a Type::Constant (used in array lengths), or is bound /// to a Type::Constant, return the constant as a u64. pub fn evaluate_to_u64(&self) -> Option { @@ -1477,14 +950,14 @@ impl Type { // in this method, you most likely want to distinguish between public and private pub fn as_abi_type(&self) -> AbiType { match self { - Type::FieldElement(_) => AbiType::Field, + Type::FieldElement => AbiType::Field, Type::Array(size, typ) => { let length = size .evaluate_to_u64() .expect("Cannot have variable sized arrays as a parameter to main"); AbiType::Array { length, typ: Box::new(typ.as_abi_type()) } } - Type::Integer(_, sign, bit_width) => { + Type::Integer(sign, bit_width) => { let sign = match sign { Signedness::Unsigned => noirc_abi::Sign::Unsigned, Signedness::Signed => noirc_abi::Sign::Signed, @@ -1492,13 +965,13 @@ impl Type { AbiType::Integer { sign, width: *bit_width } } - Type::TypeVariable(binding, TypeVariableKind::IntegerOrField(_)) => { + Type::TypeVariable(binding, TypeVariableKind::IntegerOrField) => { match &*binding.borrow() { TypeBinding::Bound(typ) => typ.as_abi_type(), - TypeBinding::Unbound(_) => Type::default_int_type(None).as_abi_type(), + TypeBinding::Unbound(_) => Type::default_int_type().as_abi_type(), } } - Type::Bool(_) => AbiType::Boolean, + Type::Bool => AbiType::Boolean, Type::String(size) => { let size = size .evaluate_to_u64() @@ -1644,9 +1117,9 @@ impl Type { Type::MutableReference(Box::new(element.substitute(type_bindings))) } - Type::FieldElement(_) - | Type::Integer(_, _, _) - | Type::Bool(_) + Type::FieldElement + | Type::Integer(_, _) + | Type::Bool | Type::Constant(_) | Type::Error | Type::NotConstant @@ -1682,9 +1155,9 @@ impl Type { } Type::MutableReference(element) => element.occurs(target_id), - Type::FieldElement(_) - | Type::Integer(_, _, _) - | Type::Bool(_) + Type::FieldElement + | Type::Integer(_, _) + | Type::Bool | Type::Constant(_) | Type::Error | Type::NotConstant @@ -1735,13 +1208,9 @@ impl Type { // Expect that this function should only be called on instantiated types Forall(..) => unreachable!(), - FieldElement(_) - | Integer(_, _, _) - | Bool(_) - | Constant(_) - | Unit - | Error - | NotConstant => self.clone(), + FieldElement | Integer(_, _) | Bool | Constant(_) | Unit | Error | NotConstant => { + self.clone() + } } } } @@ -1794,7 +1263,7 @@ impl TypeVariableKind { /// during monomorphization. pub(crate) fn default_type(&self) -> Type { match self { - TypeVariableKind::IntegerOrField(_) | TypeVariableKind::Normal => Type::field(None), + TypeVariableKind::IntegerOrField | TypeVariableKind::Normal => Type::default_int_type(), TypeVariableKind::Constant(length) => Type::Constant(*length), } } diff --git a/crates/noirc_frontend/src/monomorphization/ast.rs b/crates/noirc_frontend/src/monomorphization/ast.rs index e748cc74d13..b26db6e1afb 100644 --- a/crates/noirc_frontend/src/monomorphization/ast.rs +++ b/crates/noirc_frontend/src/monomorphization/ast.rs @@ -74,6 +74,9 @@ pub struct For { pub start_range: Box, pub end_range: Box, pub block: Box, + + pub start_range_location: Location, + pub end_range_location: Location, } #[derive(Debug, Clone)] @@ -205,7 +208,6 @@ pub struct Function { /// - All type variables and generics removed /// - Concrete lengths for each array and string /// - Several other variants removed (such as Type::Constant) -/// - No CompTime /// - All structs replaced with tuples #[derive(Debug, PartialEq, Eq, Clone)] pub enum Type { diff --git a/crates/noirc_frontend/src/monomorphization/mod.rs b/crates/noirc_frontend/src/monomorphization/mod.rs index 78d540f398e..b93c95efe07 100644 --- a/crates/noirc_frontend/src/monomorphization/mod.rs +++ b/crates/noirc_frontend/src/monomorphization/mod.rs @@ -11,7 +11,6 @@ use acvm::FieldElement; use iter_extended::{btree_map, vecmap}; use noirc_abi::FunctionSignature; -use noirc_errors::Location; use std::collections::{BTreeMap, HashMap, VecDeque}; use crate::{ @@ -336,6 +335,8 @@ impl<'interner> Monomorphizer<'interner> { index_type: Self::convert_type(&self.interner.id_type(for_expr.start_range)), start_range: Box::new(start), end_range: Box::new(end), + start_range_location: self.interner.expr_location(&for_expr.start_range), + end_range_location: self.interner.expr_location(&for_expr.end_range), block, }) } @@ -621,9 +622,9 @@ impl<'interner> Monomorphizer<'interner> { /// Convert a non-tuple/struct type to a monomorphized type fn convert_type(typ: &HirType) -> ast::Type { match typ { - HirType::FieldElement(_) => ast::Type::Field, - HirType::Integer(_, sign, bits) => ast::Type::Integer(*sign, *bits), - HirType::Bool(_) => ast::Type::Bool, + HirType::FieldElement => ast::Type::Field, + HirType::Integer(sign, bits) => ast::Type::Integer(*sign, *bits), + HirType::Bool => ast::Type::Bool, HirType::String(size) => ast::Type::String(size.evaluate_to_u64().unwrap_or(0)), HirType::FmtString(size, fields) => { let size = size.evaluate_to_u64().unwrap_or(0); @@ -654,7 +655,7 @@ impl<'interner> Monomorphizer<'interner> { // like automatic solving of traits. It should be fine since it is strictly // after type checking, but care should be taken that it doesn't change which // impls are chosen. - *binding.borrow_mut() = TypeBinding::Bound(HirType::field(None)); + *binding.borrow_mut() = TypeBinding::Bound(HirType::default_int_type()); ast::Type::Field } @@ -954,56 +955,29 @@ impl<'interner> Monomorphizer<'interner> { fn assign(&mut self, assign: HirAssignStatement) -> ast::Expression { let expression = Box::new(self.expr(assign.expression)); - let (lvalue, index_lvalue) = self.lvalue(assign.lvalue); - - match index_lvalue { - Some((index, element_type, location)) => { - let lvalue = - ast::LValue::Index { array: Box::new(lvalue), index, element_type, location }; - ast::Expression::Assign(ast::Assign { lvalue, expression }) - } - None => ast::Expression::Assign(ast::Assign { expression, lvalue }), - } + let lvalue = self.lvalue(assign.lvalue); + ast::Expression::Assign(ast::Assign { expression, lvalue }) } - /// Returns the lvalue along with an optional LValue::Index to add to the end, if needed. - /// This is added to the end separately as part of converting arrays of structs to structs - /// of arrays. - fn lvalue( - &mut self, - lvalue: HirLValue, - ) -> (ast::LValue, Option<(Box, ast::Type, Location)>) { + fn lvalue(&mut self, lvalue: HirLValue) -> ast::LValue { match lvalue { - HirLValue::Ident(ident, _) => { - let lvalue = ast::LValue::Ident(self.local_ident(&ident).unwrap()); - (lvalue, None) - } + HirLValue::Ident(ident, _) => ast::LValue::Ident(self.local_ident(&ident).unwrap()), HirLValue::MemberAccess { object, field_index, .. } => { let field_index = field_index.unwrap(); - let (object, index) = self.lvalue(*object); - let object = Box::new(object); - let lvalue = ast::LValue::MemberAccess { object, field_index }; - (lvalue, index) + let object = Box::new(self.lvalue(*object)); + ast::LValue::MemberAccess { object, field_index } } HirLValue::Index { array, index, typ } => { let location = self.interner.expr_location(&index); - - let (array, prev_index) = self.lvalue(*array); - assert!( - prev_index.is_none(), - "Nested arrays are currently unsupported in noir: location is {location:?}" - ); - + let array = Box::new(self.lvalue(*array)); let index = Box::new(self.expr(index)); let element_type = Self::convert_type(&typ); - (array, Some((index, element_type, location))) + ast::LValue::Index { array, index, element_type, location } } HirLValue::Dereference { lvalue, element_type } => { - let (reference, index) = self.lvalue(*lvalue); - let reference = Box::new(reference); + let reference = Box::new(self.lvalue(*lvalue)); let element_type = Self::convert_type(&element_type); - let lvalue = ast::LValue::Dereference { reference, element_type }; - (lvalue, index) + ast::LValue::Dereference { reference, element_type } } } } diff --git a/crates/noirc_frontend/src/node_interner.rs b/crates/noirc_frontend/src/node_interner.rs index 6b3d2757c14..ad1638c3f0b 100644 --- a/crates/noirc_frontend/src/node_interner.rs +++ b/crates/noirc_frontend/src/node_interner.rs @@ -664,11 +664,11 @@ fn get_type_method_key(typ: &Type) -> Option { use TypeMethodKey::*; let typ = typ.follow_bindings(); match &typ { - Type::FieldElement(_) => Some(FieldOrInt), + Type::FieldElement => Some(FieldOrInt), Type::Array(_, _) => Some(Array), - Type::Integer(_, _, _) => Some(FieldOrInt), - Type::TypeVariable(_, TypeVariableKind::IntegerOrField(_)) => Some(FieldOrInt), - Type::Bool(_) => Some(Bool), + Type::Integer(_, _) => Some(FieldOrInt), + Type::TypeVariable(_, TypeVariableKind::IntegerOrField) => Some(FieldOrInt), + Type::Bool => Some(Bool), Type::String(_) => Some(String), Type::Unit => Some(Unit), Type::Tuple(_) => Some(Tuple), diff --git a/crates/noirc_frontend/src/parser/errors.rs b/crates/noirc_frontend/src/parser/errors.rs index af27f1445f7..7c048f2a0c5 100644 --- a/crates/noirc_frontend/src/parser/errors.rs +++ b/crates/noirc_frontend/src/parser/errors.rs @@ -25,6 +25,8 @@ pub enum ParserErrorReason { EarlyReturn, #[error("Patterns aren't allowed in a trait's function declarations")] PatternInTraitFunctionParameter, + #[error("comptime keyword is deprecated")] + ComptimeDeprecated, #[error("{0} are experimental and aren't fully supported yet")] ExperimentalFeature(&'static str), } @@ -117,6 +119,11 @@ impl From for Diagnostic { "The 'constrain' keyword has been deprecated. Please use the 'assert' function instead.".into(), error.span, ), + ParserErrorReason::ComptimeDeprecated => Diagnostic::simple_warning( + "Use of deprecated keyword 'comptime'".into(), + "The 'comptime' keyword has been deprecated. It can be removed without affecting your program".into(), + error.span, + ), ParserErrorReason::ExperimentalFeature(_) => Diagnostic::simple_warning( reason.to_string(), "".into(), diff --git a/crates/noirc_frontend/src/parser/parser.rs b/crates/noirc_frontend/src/parser/parser.rs index 6e636ef9fa2..232aff618b0 100644 --- a/crates/noirc_frontend/src/parser/parser.rs +++ b/crates/noirc_frontend/src/parser/parser.rs @@ -34,10 +34,10 @@ use crate::lexer::Lexer; use crate::parser::{force, ignore_then_commit, statement_recovery}; use crate::token::{Attribute, Keyword, Token, TokenKind}; use crate::{ - BinaryOp, BinaryOpKind, BlockExpression, CompTime, ConstrainStatement, FunctionDefinition, - Ident, IfExpression, InfixExpression, LValue, Lambda, Literal, NoirFunction, NoirStruct, - NoirTrait, NoirTypeAlias, Path, PathKind, Pattern, Recoverable, TraitConstraint, TraitImpl, - TraitImplItem, TraitItem, TypeImpl, UnaryOp, UnresolvedTypeExpression, UseTree, UseTreeKind, + BinaryOp, BinaryOpKind, BlockExpression, ConstrainStatement, FunctionDefinition, Ident, + IfExpression, InfixExpression, LValue, Lambda, Literal, NoirFunction, NoirStruct, NoirTrait, + NoirTypeAlias, Path, PathKind, Pattern, Recoverable, TraitConstraint, TraitImpl, TraitImplItem, + TraitItem, TypeImpl, UnaryOp, UnresolvedTypeExpression, UseTree, UseTreeKind, }; use chumsky::prelude::*; @@ -125,7 +125,7 @@ fn global_declaration() -> impl NoirParser { keyword(Keyword::Global).labelled(ParsingRuleLabel::Global), ident().map(Pattern::Identifier), ); - let p = then_commit(p, global_type_annotation()); + let p = then_commit(p, optional_type_annotation()); let p = then_commit_ignore(p, just(Token::Assign)); let p = then_commit(p, literal_or_collection(expression()).map_with_span(Expression::new)); p.map(LetStatement::new_let).map(TopLevelStatement::Global) @@ -548,21 +548,7 @@ fn check_statements_require_semicolon( }) } -/// Parse an optional ': type' and implicitly add a 'comptime' to the type -fn global_type_annotation() -> impl NoirParser { - ignore_then_commit(just(Token::Colon), parse_type()) - .map(|r#type| match r#type { - UnresolvedType::FieldElement(_) => UnresolvedType::FieldElement(CompTime::Yes(None)), - UnresolvedType::Bool(_) => UnresolvedType::Bool(CompTime::Yes(None)), - UnresolvedType::Integer(_, sign, size) => { - UnresolvedType::Integer(CompTime::Yes(None), sign, size) - } - other => other, - }) - .or_not() - .map(|opt| opt.unwrap_or(UnresolvedType::Unspecified)) -} - +/// Parse an optional ': type' fn optional_type_annotation<'a>() -> impl NoirParser + 'a { ignore_then_commit(just(Token::Colon), parse_type()) .or_not() @@ -834,19 +820,20 @@ fn optional_distinctness() -> impl NoirParser { }) } -fn maybe_comp_time() -> impl NoirParser { - keyword(Keyword::CompTime).or_not().map(|opt| match opt { - Some(_) => CompTime::Yes(None), - None => CompTime::No(None), +fn maybe_comp_time() -> impl NoirParser<()> { + keyword(Keyword::CompTime).or_not().validate(|opt, span, emit| { + if opt.is_some() { + emit(ParserError::with_reason(ParserErrorReason::ComptimeDeprecated, span)); + } }) } fn field_type() -> impl NoirParser { - maybe_comp_time().then_ignore(keyword(Keyword::Field)).map(UnresolvedType::FieldElement) + maybe_comp_time().then_ignore(keyword(Keyword::Field)).map(|_| UnresolvedType::FieldElement) } fn bool_type() -> impl NoirParser { - maybe_comp_time().then_ignore(keyword(Keyword::Bool)).map(UnresolvedType::Bool) + maybe_comp_time().then_ignore(keyword(Keyword::Bool)).map(|_| UnresolvedType::Bool) } fn string_type() -> impl NoirParser { @@ -878,9 +865,9 @@ fn int_type() -> impl NoirParser { Err(ParserError::expected_label(ParsingRuleLabel::IntegerType, unexpected, span)) } })) - .validate(|token, span, emit| { + .validate(|(_, token), span, emit| { let typ = UnresolvedType::from_int_token(token); - if let UnresolvedType::Integer(_, crate::Signedness::Signed, _) = &typ { + if let UnresolvedType::Integer(crate::Signedness::Signed, _) = &typ { let reason = ParserErrorReason::ExperimentalFeature("Signed integer types"); emit(ParserError::with_reason(reason, span)); } @@ -1754,7 +1741,7 @@ mod test { vec![ "fn func_name() {}", "fn f(foo: pub u8, y : pub Field) -> u8 { x + a }", - "fn f(f: pub Field, y : Field, z : comptime Field) -> u8 { x + a }", + "fn f(f: pub Field, y : Field, z : Field) -> u8 { x + a }", "fn func_name(f: Field, y : pub Field, z : pub [u8;5],) {}", "fn func_name(x: [Field], y : [Field;2],y : pub [Field;2], z : pub [u8;5]) {}", "fn main(x: pub u8, y: pub u8) -> distinct pub [u8; 2] { [x, y] }", diff --git a/noir_stdlib/src/array.nr b/noir_stdlib/src/array.nr index db349317f91..9082e161e91 100644 --- a/noir_stdlib/src/array.nr +++ b/noir_stdlib/src/array.nr @@ -3,7 +3,7 @@ // by the methods in the `slice` module impl [T; N] { #[builtin(array_len)] - fn len(_self: Self) -> comptime Field {} + fn len(_self: Self) -> Field {} #[builtin(arraysort)] fn sort(_self: Self) -> Self {} diff --git a/noir_stdlib/src/ec/montcurve.nr b/noir_stdlib/src/ec/montcurve.nr index e917661f0f1..e698a7841e5 100644 --- a/noir_stdlib/src/ec/montcurve.nr +++ b/noir_stdlib/src/ec/montcurve.nr @@ -41,12 +41,12 @@ mod affine { // Check if zero fn is_zero(self) -> bool { - self.infty == true + self.infty } // Conversion to CurveGroup coordinates fn into_group(self) -> curvegroup::Point { - if self.is_zero() == true { + if self.is_zero() { curvegroup::Point::zero() } else { let (x,y) = (self.x, self.y); @@ -70,7 +70,7 @@ mod affine { fn into_tecurve(self) -> TEPoint { let Self {x, y, infty} = self; - if (infty == true) | (y*(x+1) == 0) { + if infty | (y*(x+1) == 0) { TEPoint::zero() } else { TEPoint::new(x/y, (x-1)/(x+1)) @@ -126,7 +126,7 @@ mod affine { fn msm(self, n: [Field; N], p: [Point; N]) -> Point { let mut out = Point::zero(); - for i in 0..n.len() { + for i in 0..N { out = self.add(out, self.mul(n[i], p[i])); } @@ -156,7 +156,7 @@ mod affine { // Point mapping into equivalent Short Weierstraß curve fn map_into_swcurve(self, p: Point) -> SWPoint { - if p.is_zero() == true { + if p.is_zero() { SWPoint::zero() } else { SWPoint::new((3*p.x + self.j)/(3*self.k), @@ -191,9 +191,9 @@ mod affine { let x2 = 0 - x1 - (j/k); let gx2 = x2*x2*x2 + (j/k)*x2*x2 + x2/(k*k); - let x = if is_square(gx1) == true { x1 } else { x2 }; + let x = if is_square(gx1) { x1 } else { x2 }; - let y = if is_square(gx1) == true { + let y = if is_square(gx1) { let y0 = sqrt(gx1); if y0.sgn0() == 1 { y0 } else { 0 - y0 } } else { @@ -254,7 +254,7 @@ mod curvegroup { // Conversion to affine coordinates fn into_affine(self) -> affine::Point { - if self.is_zero() == true{ + if self.is_zero() { affine::Point::zero() } else { let (x,y,z) = (self.x, self.y, self.z); @@ -328,7 +328,7 @@ mod curvegroup { fn msm(self, n: [Field; N], p: [Point; N]) -> Point { let mut out = Point::zero(); - for i in 0..n.len() { + for i in 0..N { out = self.add(out, self.mul(n[i], p[i])); } diff --git a/noir_stdlib/src/ec/swcurve.nr b/noir_stdlib/src/ec/swcurve.nr index 1f22de5598f..3e4f57c1fa3 100644 --- a/noir_stdlib/src/ec/swcurve.nr +++ b/noir_stdlib/src/ec/swcurve.nr @@ -48,7 +48,7 @@ mod affine { fn into_group(self) -> curvegroup::Point { let Self {x, y, infty} = self; - if infty == true { + if infty { curvegroup::Point::zero() } else { curvegroup::Point::new(x, y, 1) @@ -73,7 +73,7 @@ mod affine { // Check curve coefficients assert(4*a*a*a + 27*b*b != 0); - let curve = Curve { a, b, gen }; + let curve = Curve { a, b, gen }; // gen should be on the curve assert(curve.contains(curve.gen)); @@ -147,7 +147,7 @@ mod affine { fn msm(self, n: [Field; N], p: [Point; N]) -> Point { let mut out = Point::zero(); - for i in 0..n.len() { + for i in 0..N { out = self.add(out, self.mul(n[i], p[i])); } @@ -173,7 +173,7 @@ mod affine { let gx1 = x1*x1*x1 + a*x1 + b; let x2 = z*u*u*x1; let gx2 = x2*x2*x2 + a*x2 + b; - let (x,y) = if is_square(gx1) == true {(x1, sqrt(gx1))} else {(x2, sqrt(gx2))}; + let (x,y) = if is_square(gx1) {(x1, sqrt(gx1))} else {(x2, sqrt(gx2))}; Point::new(x, if u.sgn0() != y.sgn0() {0-y} else {y}) } } @@ -250,7 +250,7 @@ mod curvegroup { // Check curve coefficients assert(4*a*a*a + 27*b*b != 0); - let curve = Curve { a, b, gen }; + let curve = Curve { a, b, gen }; // gen should be on the curve assert(curve.contains(curve.gen)); @@ -331,12 +331,11 @@ mod curvegroup { // If k is the natural number represented by `bits`, then this computes p + ... + p k times. fn bit_mul(self, bits: [u1; N], p: Point) -> Point { let mut out = Point::zero(); - let n = bits.len(); - for i in 0..n { + for i in 0..N { out = self.add( self.add(out, out), - if(bits[n - i - 1] == 0) {Point::zero()} else {p}); + if(bits[N - i - 1] == 0) {Point::zero()} else {p}); } out @@ -360,7 +359,7 @@ mod curvegroup { fn msm(self, n: [Field; N], p: [Point; N]) -> Point { let mut out = Point::zero(); - for i in 0..n.len() { + for i in 0..N { out = self.add(out, self.mul(n[i], p[i])); } diff --git a/noir_stdlib/src/ec/tecurve.nr b/noir_stdlib/src/ec/tecurve.nr index ff2c398a8a9..90be8833206 100644 --- a/noir_stdlib/src/ec/tecurve.nr +++ b/noir_stdlib/src/ec/tecurve.nr @@ -64,7 +64,7 @@ mod affine { // Map into prime-order subgroup of equivalent Montgomery curve fn into_montcurve(self) -> MPoint { - if self.is_zero() == true { + if self.is_zero() { MPoint::zero() } else { let Self {x, y} = self; @@ -83,7 +83,7 @@ mod affine { // Check curve coefficients assert(a*d*(a-d) != 0); - let curve = Curve {a, d, gen}; + let curve = Curve {a, d, gen}; // gen should be on the curve assert(curve.contains(curve.gen)); @@ -145,7 +145,7 @@ mod affine { fn msm(self, n: [Field; N], p: [Point; N]) -> Point { let mut out = Point::zero(); - for i in 0..n.len() { + for i in 0..N { out = self.add(out, self.mul(n[i], p[i])); } @@ -227,34 +227,16 @@ mod curvegroup { // Check for equality fn eq(self, p: Point) -> bool { - if self.is_zero() == true { - p.is_zero() - } else if p.is_zero() == true { - false - } else { - let Self {x: x1, y: y1, t: _t1, z: z1} = self; - let Self {x: x2, y: y2, t: _t2, z:z2} = p; - - if x1*z2 == x2*z1 { - y1*z2 == y2*z1 - } else { - false - } - } + let Self {x: x1, y: y1, t: _t1, z: z1} = self; + let Self {x: x2, y: y2, t: _t2, z:z2} = p; + + (x1*z2 == x2*z1) & (y1*z2 == y2*z1) } // Check if zero fn is_zero(self) -> bool { let Self {x, y, t, z} = self; - if y == z { - if x == t { - x == 0 - } else { - false - } - } else { - false - } + (x == 0) & (y == z) & (y != 0) & (t == 0) } // Conversion to affine coordinates @@ -288,7 +270,7 @@ mod curvegroup { // Check curve coefficients assert(a*d*(a-d) != 0); - let curve = Curve { a, d, gen }; + let curve = Curve { a, d, gen }; // gen should be on the curve assert(curve.contains(curve.gen)); @@ -307,7 +289,7 @@ mod curvegroup { fn contains(self, p: Point) -> bool { let Point {x, y, t, z} = p; - (z != 0) & (z*t == x*y) & (z*z*(self.a*x*x + y*y) == z*z + self.d*x*x*y*y) + (z != 0) & (z*t == x*y) & (z*z*(self.a*x*x + y*y) == z*z*z*z + self.d*x*x*y*y) } // Point addition @@ -357,12 +339,11 @@ mod curvegroup { // If k is the natural number represented by `bits`, then this computes p + ... + p k times. fn bit_mul(self, bits: [u1; N], p: Point) -> Point { let mut out = Point::zero(); - let n = bits.len(); - for i in 0..n { + for i in 0..N { out = self.add( self.add(out, out), - if(bits[n - i - 1] == 0) {Point::zero()} else {p}); + if(bits[N - i - 1] == 0) {Point::zero()} else {p}); } out @@ -386,7 +367,7 @@ mod curvegroup { fn msm(self, n: [Field; N], p: [Point; N]) -> Point { let mut out = Point::zero(); - for i in 0..n.len() { + for i in 0..N { out = self.add(out, self.mul(n[i], p[i])); } diff --git a/noir_stdlib/src/field.nr b/noir_stdlib/src/field.nr index b7773182d66..5d3581689f5 100644 --- a/noir_stdlib/src/field.nr +++ b/noir_stdlib/src/field.nr @@ -40,7 +40,7 @@ impl Field { } #[builtin(modulus_num_bits)] -fn modulus_num_bits() -> comptime Field {} +fn modulus_num_bits() -> Field {} #[builtin(modulus_be_bits)] fn modulus_be_bits() -> [u1] {} diff --git a/noir_stdlib/src/hash.nr b/noir_stdlib/src/hash.nr index e5dbdadaf7f..5b0db2f2941 100644 --- a/noir_stdlib/src/hash.nr +++ b/noir_stdlib/src/hash.nr @@ -11,7 +11,7 @@ fn pedersen(input : [Field; N]) -> [Field; 2] { } #[foreign(pedersen)] -fn pedersen_with_separator(_input : [Field; N], _separator : comptime u32) -> [Field; 2] {} +fn pedersen_with_separator(_input : [Field; N], _separator : u32) -> [Field; 2] {} #[foreign(hash_to_field_128_security)] fn hash_to_field(_input : [Field; N]) -> Field {} diff --git a/noir_stdlib/src/hash/poseidon.nr b/noir_stdlib/src/hash/poseidon.nr index cb1e34927b4..cb97716d987 100644 --- a/noir_stdlib/src/hash/poseidon.nr +++ b/noir_stdlib/src/hash/poseidon.nr @@ -3,19 +3,19 @@ mod bn254; // Instantiations of Poseidon for prime field of the same order as BN use crate::field::modulus_num_bits; struct PoseidonConfig { - t: comptime Field, // Width, i.e. state size - rf: comptime u8, // Number of full rounds; should be even - rp: comptime u8, // Number of partial rounds - alpha: comptime Field, // S-box power; depends on the underlying field + t: Field, // Width, i.e. state size + rf: u8, // Number of full rounds; should be even + rp: u8, // Number of partial rounds + alpha: Field, // S-box power; depends on the underlying field ark: [Field; M], // Additive round keys mds: [Field; N] // MDS Matrix in row-major order } fn config( - t: comptime Field, - rf: comptime u8, - rp: comptime u8, - alpha: comptime Field, + t: Field, + rf: u8, + rp: u8, + alpha: Field, ark: [Field; M], mds: [Field; N]) -> PoseidonConfig { @@ -64,8 +64,8 @@ fn permute( fn absorb( pos_conf: PoseidonConfig, mut state: [Field; O], // Initial state; usually [0; O] - rate: comptime Field, // Rate - capacity: comptime Field, // Capacity; usually 1 + rate: Field, // Rate + capacity: Field, // Capacity; usually 1 msg: [Field; P]) // Arbitrary length message -> [Field; O] { assert(pos_conf.t == rate + capacity); diff --git a/noir_stdlib/src/hash/poseidon/bn254.nr b/noir_stdlib/src/hash/poseidon/bn254.nr index 9ba26dbd878..0b4e5b5bf41 100644 --- a/noir_stdlib/src/hash/poseidon/bn254.nr +++ b/noir_stdlib/src/hash/poseidon/bn254.nr @@ -68,8 +68,8 @@ fn permute( fn absorb( pos_conf: PoseidonConfig, mut state: [Field; O], // Initial state; usually [0; O] - rate: comptime Field, // Rate - capacity: comptime Field, // Capacity; usually 1 + rate: Field, // Rate + capacity: Field, // Capacity; usually 1 msg: [Field; P] // Arbitrary length message ) -> [Field; O] { diff --git a/noir_stdlib/src/hash/poseidon/bn254/consts.nr b/noir_stdlib/src/hash/poseidon/bn254/consts.nr index daa5260e59d..83923eff6ef 100644 --- a/noir_stdlib/src/hash/poseidon/bn254/consts.nr +++ b/noir_stdlib/src/hash/poseidon/bn254/consts.nr @@ -12,7 +12,7 @@ fn rp() -> [u8; 16] { } // S-box power -fn alpha() -> comptime Field { +fn alpha() -> Field { 5 } diff --git a/noir_stdlib/src/slice.nr b/noir_stdlib/src/slice.nr index 8e344a40f5e..4f73f3a2994 100644 --- a/noir_stdlib/src/slice.nr +++ b/noir_stdlib/src/slice.nr @@ -32,5 +32,13 @@ impl [T] { /// the removed element #[builtin(slice_remove)] fn remove(_self: Self, _index: Field) -> (Self, T) { } -} + // Append each element of the `other` slice to the end of `self`. + // This returns a new slice and leaves both input slices unchanged. + fn append(mut self, other: Self) -> Self { + for elem in other { + self = self.push_back(elem); + } + self + } +}