Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

Fix most Cargo warnings on nightly (#14298)

Alex Crichton5c6920e1a5b0
diff --git a/Cargo.lock b/Cargo.lock
index e576aef4a0..4e6c230d18 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -334,7 +334,6 @@ version = "0.1.0"
dependencies = [
"clap",
"wasmtime",
- "wasmtime-wasi",
]
[[package]]
@@ -800,9 +799,7 @@ dependencies = [
"smallvec 1.15.1",
"target-lexicon 0.13.5",
"thiserror 2.0.17",
- "toml",
"wasmtime-internal-unwinder",
- "wat",
]
[[package]]
@@ -1040,7 +1037,6 @@ dependencies = [
"similar",
"target-lexicon 0.13.5",
"thiserror 2.0.17",
- "toml",
"walkdir",
]
@@ -3774,7 +3770,6 @@ dependencies = [
"flate2",
"futures",
"libc",
- "once_cell",
"regex",
"sha2",
"url",
diff --git a/Cargo.toml b/Cargo.toml
index 61666ce647..788946ab61 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,7 +8,6 @@ documentation = "https://bytecodealliance.github.io/wasmtime/cli.html"
categories = ["wasm"]
keywords = ["webassembly", "wasm"]
repository = "https://github.com/bytecodealliance/wasmtime"
-readme = "README.md"
edition.workspace = true
default-run = "wasmtime"
rust-version.workspace = true
@@ -350,13 +349,11 @@ cranelift = { path = "cranelift/umbrella", version = "0.137.0-dev" }
winch-codegen = { path = "winch/codegen", version = "=50.0.0-dev" }
# Internal crates not published to crates.io used in testing, builds, etc
-wasi-preview1-component-adapter = { path = "crates/wasi-preview1-component-adapter" }
wasmtime-fuzzing = { path = "crates/fuzzing", default-features = false }
test-programs-artifacts = { path = 'crates/test-programs/artifacts' }
wasmtime-test-util = { path = "crates/test-util" }
byte-array-literals = { path = "crates/wasi-preview1-component-adapter/byte-array-literals" }
pulley-interpreter-fuzz = { path = 'pulley/fuzz' }
-component-async-tests = { path = "crates/misc/component-async-tests" }
# Bytecode Alliance maintained dependencies:
# ---------------------------
@@ -417,14 +414,12 @@ similar = "3.1.1"
toml = "1.1.4"
mach2 = "0.6"
memfd = "0.6.5"
-psm = "0.1.11"
proptest = "1.11.0"
rand = { version = "0.10.1", default-features = false }
# serde and serde_derive must have the same version
serde = { version = "1.0.228", default-features = false, features = ['alloc'] }
serde_derive = "1.0.228"
serde_json = "1.0.80"
-glob = "0.3.3"
libfuzzer-sys = "0.4.10"
walkdir = "2.5.0"
tempfile = "3.27.0"
@@ -458,7 +453,6 @@ tokio-native-tls = "0.3.1"
native-tls = "0.2.11"
tokio-openssl = "0.6.5"
openssl = "0.10.80"
-openssl-sys = "0.9.116"
webpki-roots = "1.0.7"
itertools = "0.14.0"
base64 = "0.22.1"
diff --git a/cranelift/Cargo.toml b/cranelift/Cargo.toml
index 7c2c651084..ac3786288e 100644
--- a/cranelift/Cargo.toml
+++ b/cranelift/Cargo.toml
@@ -44,7 +44,6 @@ walkdir = { workspace = true }
anyhow = { workspace = true }
clap = { workspace = true, features = ['default'] }
similar = { workspace = true }
-toml = { workspace = true }
serde = { workspace = true }
rustc-hash = { workspace = true }
# Note that this just enables `trace-log` for `clif-util` and doesn't turn it on
diff --git a/cranelift/assembler-x64/fuzz/Cargo.toml b/cranelift/assembler-x64/fuzz/Cargo.toml
index 384a47e385..798ddc3ee1 100644
--- a/cranelift/assembler-x64/fuzz/Cargo.toml
+++ b/cranelift/assembler-x64/fuzz/Cargo.toml
@@ -5,6 +5,9 @@ publish = false
edition.workspace = true
rust-version.workspace = true
+[lints]
+workspace = true
+
[package.metadata]
cargo-fuzz = true
diff --git a/cranelift/bforest/Cargo.toml b/cranelift/bforest/Cargo.toml
index 5a0979e870..f30ea0a03a 100644
--- a/cranelift/bforest/Cargo.toml
+++ b/cranelift/bforest/Cargo.toml
@@ -7,7 +7,6 @@ license = "Apache-2.0 WITH LLVM-exception"
documentation = "https://docs.rs/cranelift-bforest"
repository = "https://github.com/bytecodealliance/wasmtime"
categories = ["no-std"]
-readme = "README.md"
keywords = ["btree", "forest", "set", "map"]
edition.workspace = true
rust-version.workspace = true
diff --git a/cranelift/codegen/Cargo.toml b/cranelift/codegen/Cargo.toml
index fe6c9132d7..ae4afc0f50 100644
--- a/cranelift/codegen/Cargo.toml
+++ b/cranelift/codegen/Cargo.toml
@@ -7,7 +7,6 @@ license = "Apache-2.0 WITH LLVM-exception"
documentation = "https://docs.rs/cranelift-codegen"
repository = "https://github.com/bytecodealliance/wasmtime"
categories = ["no-std"]
-readme = "README.md"
keywords = ["compile", "compiler", "jit"]
build = "build.rs"
edition.workspace = true
diff --git a/cranelift/codegen/meta/Cargo.toml b/cranelift/codegen/meta/Cargo.toml
index ec553f84c0..7cc081a23c 100644
--- a/cranelift/codegen/meta/Cargo.toml
+++ b/cranelift/codegen/meta/Cargo.toml
@@ -5,7 +5,6 @@ version = "0.137.0-dev"
description = "Metaprogram for cranelift-codegen code generator library"
license = "Apache-2.0 WITH LLVM-exception"
repository = "https://github.com/bytecodealliance/wasmtime"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
diff --git a/cranelift/codegen/shared/Cargo.toml b/cranelift/codegen/shared/Cargo.toml
index 838ad25940..ad2fc15ea3 100644
--- a/cranelift/codegen/shared/Cargo.toml
+++ b/cranelift/codegen/shared/Cargo.toml
@@ -5,10 +5,12 @@ version = "0.137.0-dev"
description = "For code shared between cranelift-codegen-meta and cranelift-codegen"
license = "Apache-2.0 WITH LLVM-exception"
repository = "https://github.com/bytecodealliance/wasmtime"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
+[lints]
+workspace = true
+
[dependencies]
# Since this is a shared dependency of several packages, please strive to keep this dependency-free
# when no features are enabled.
diff --git a/cranelift/control/Cargo.toml b/cranelift/control/Cargo.toml
index 4b5fcd214b..d3a294797f 100644
--- a/cranelift/control/Cargo.toml
+++ b/cranelift/control/Cargo.toml
@@ -5,11 +5,13 @@ version = "0.137.0-dev"
description = "White-box fuzz testing framework"
license = "Apache-2.0 WITH LLVM-exception"
repository = "https://github.com/bytecodealliance/wasmtime"
-readme = "README.md"
keywords = ["fuzz", "test"]
edition.workspace = true
rust-version.workspace = true
+[lints]
+workspace = true
+
[dependencies]
arbitrary = { workspace = true, optional = true }
diff --git a/cranelift/entity/Cargo.toml b/cranelift/entity/Cargo.toml
index 02b0745410..7d3f87057a 100644
--- a/cranelift/entity/Cargo.toml
+++ b/cranelift/entity/Cargo.toml
@@ -7,7 +7,6 @@ license = "Apache-2.0 WITH LLVM-exception"
documentation = "https://docs.rs/cranelift-entity"
repository = "https://github.com/bytecodealliance/wasmtime"
categories = ["no-std"]
-readme = "README.md"
keywords = ["entity", "set", "map"]
edition.workspace = true
rust-version.workspace = true
diff --git a/cranelift/filetests/Cargo.toml b/cranelift/filetests/Cargo.toml
index 92118fd4de..1964c21501 100644
--- a/cranelift/filetests/Cargo.toml
+++ b/cranelift/filetests/Cargo.toml
@@ -32,8 +32,6 @@ target-lexicon = { workspace = true }
thiserror = { workspace = true }
anyhow = { workspace = true }
similar = { workspace = true }
-wat.workspace = true
-toml = { workspace = true }
serde = { workspace = true }
serde_derive = { workspace = true }
cranelift.workspace = true
diff --git a/cranelift/frontend/Cargo.toml b/cranelift/frontend/Cargo.toml
index e8c8e37fb6..827540d831 100644
--- a/cranelift/frontend/Cargo.toml
+++ b/cranelift/frontend/Cargo.toml
@@ -7,7 +7,6 @@ license = "Apache-2.0 WITH LLVM-exception"
documentation = "https://docs.rs/cranelift-frontend"
categories = ["no-std"]
repository = "https://github.com/bytecodealliance/wasmtime"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
diff --git a/cranelift/fuzzgen/Cargo.toml b/cranelift/fuzzgen/Cargo.toml
index fb323ad31d..fa732f07bc 100644
--- a/cranelift/fuzzgen/Cargo.toml
+++ b/cranelift/fuzzgen/Cargo.toml
@@ -5,7 +5,6 @@ authors = ["The Wasmtime Project Developers"]
description = "Cranelift module generator"
license = "Apache-2.0 WITH LLVM-exception"
repository = "https://github.com/bytecodealliance/wasmtime"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
publish = false
diff --git a/cranelift/interpreter/Cargo.toml b/cranelift/interpreter/Cargo.toml
index 419d541473..614fb77578 100644
--- a/cranelift/interpreter/Cargo.toml
+++ b/cranelift/interpreter/Cargo.toml
@@ -7,7 +7,6 @@ repository = "https://github.com/bytecodealliance/wasmtime"
documentation = "https://docs.rs/cranelift-interpreter"
categories = ["no-std"]
license = "Apache-2.0 WITH LLVM-exception"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
diff --git a/cranelift/isle/fuzz/Cargo.toml b/cranelift/isle/fuzz/Cargo.toml
index 9a2b073d71..667b34dd62 100644
--- a/cranelift/isle/fuzz/Cargo.toml
+++ b/cranelift/isle/fuzz/Cargo.toml
@@ -9,6 +9,9 @@ rust-version.workspace = true
[package.metadata]
cargo-fuzz = true
+[lints]
+workspace = true
+
[dependencies]
env_logger = { workspace = true }
cranelift-isle = { path = "../isle" }
diff --git a/cranelift/isle/islec/Cargo.toml b/cranelift/isle/islec/Cargo.toml
index b666dd9b96..0280067ba3 100644
--- a/cranelift/isle/islec/Cargo.toml
+++ b/cranelift/isle/islec/Cargo.toml
@@ -7,6 +7,9 @@ rust-version.workspace = true
license = "Apache-2.0 WITH LLVM-exception"
publish = false
+[lints]
+workspace = true
+
[dependencies]
cranelift-isle = { path = "../isle/", features = ["fancy-errors", "logging"] }
env_logger = { workspace = true }
diff --git a/cranelift/isle/veri/aslp/Cargo.toml b/cranelift/isle/veri/aslp/Cargo.toml
index 831b956269..8a62ab2427 100644
--- a/cranelift/isle/veri/aslp/Cargo.toml
+++ b/cranelift/isle/veri/aslp/Cargo.toml
@@ -4,6 +4,9 @@ version = "0.1.0"
edition = "2021"
publish = false
+[lints]
+workspace = true
+
[dependencies]
pest = "2.8.6"
pest_derive = "2.8.6"
@@ -11,7 +14,6 @@ clap = { workspace = true }
anyhow = { workspace = true, features = ['std', 'backtrace'] }
tracing = { workspace = true }
tracing-subscriber = { workspace = true }
-cranelift-isle-veri-test-macros = { path = "../test-macros" }
hyper = { workspace = true, features = ["client", "http1"] }
http-body-util = { workspace = true }
tokio = { workspace = true, features = ["rt", "net"] }
@@ -19,3 +21,6 @@ bytes = { workspace = true }
url = { workspace = true }
serde = { workspace = true, features = ["derive"] }
serde_json = { workspace = true }
+
+[dev-dependencies]
+cranelift-isle-veri-test-macros = { path = "../test-macros" }
diff --git a/cranelift/isle/veri/caching/Cargo.toml b/cranelift/isle/veri/caching/Cargo.toml
index e331d43cd3..fc3fb2743d 100644
--- a/cranelift/isle/veri/caching/Cargo.toml
+++ b/cranelift/isle/veri/caching/Cargo.toml
@@ -5,6 +5,9 @@ edition.workspace = true
publish = false
description = "Transparent caching layer over easy-smt for the ISLE verifier"
+[lints]
+workspace = true
+
[dependencies]
easy-smt = "0.3.2"
log = { workspace = true }
diff --git a/cranelift/isle/veri/isaspec/Cargo.toml b/cranelift/isle/veri/isaspec/Cargo.toml
index 27b38d35b0..db0a82fe79 100644
--- a/cranelift/isle/veri/isaspec/Cargo.toml
+++ b/cranelift/isle/veri/isaspec/Cargo.toml
@@ -4,6 +4,9 @@ version = "0.1.0"
publish = false
edition.workspace = true
+[lints]
+workspace = true
+
[dependencies]
cranelift-isle-veri-aslp = { path = "../aslp" }
cranelift-isle = { path = "../../isle" }
diff --git a/cranelift/isle/veri/isaspec/src/bits.rs b/cranelift/isle/veri/isaspec/src/bits.rs
index a491fb79ab..582a3d5e7d 100644
--- a/cranelift/isle/veri/isaspec/src/bits.rs
+++ b/cranelift/isle/veri/isaspec/src/bits.rs
@@ -36,8 +36,7 @@ impl Bits {
for segment in &self.segments {
let value = match segment {
Segment::Symbolic(name, _) => assignment.get(name).ok_or(format_err!(
- "missing assignment for symbolic segment: {}",
- name
+ "missing assignment for symbolic segment: {name}",
))?,
Segment::Constant(c, _) => c,
};
diff --git a/cranelift/isle/veri/isaspec/src/configure.rs b/cranelift/isle/veri/isaspec/src/configure.rs
index c731f1139b..9817af9585 100644
--- a/cranelift/isle/veri/isaspec/src/configure.rs
+++ b/cranelift/isle/veri/isaspec/src/configure.rs
@@ -222,11 +222,7 @@ where
let opcode = aarch64::opcode(&inst);
let got = concrete.eval()?;
if got != opcode {
- bail!(
- "template mismatch: opcode {:#x}, template {:#x}",
- opcode,
- got,
- );
+ bail!("template mismatch: opcode {opcode:#x}, template {got:#x}");
}
}
Ok(())
diff --git a/cranelift/isle/veri/isaspec/src/instructions.rs b/cranelift/isle/veri/isaspec/src/instructions.rs
index 6c184abc5e..311ce50e1d 100644
--- a/cranelift/isle/veri/isaspec/src/instructions.rs
+++ b/cranelift/isle/veri/isaspec/src/instructions.rs
@@ -464,7 +464,7 @@ fn alu_rrr_shift_size_case(alu_op: ALUOp, size: OperandSize, op: ShiftOp) -> Res
OperandSize::Size32 => 5,
OperandSize::Size64 => 6,
};
- let amt_var = format!("amt{}", amt_width);
+ let amt_var = format!("amt{amt_width}");
// Setup scope with shift amount variable.
let amt_target = Target::Var(amt_var.clone());
diff --git a/cranelift/isle/veri/test-macros/Cargo.toml b/cranelift/isle/veri/test-macros/Cargo.toml
index b954fe55ef..5a5f4ad534 100644
--- a/cranelift/isle/veri/test-macros/Cargo.toml
+++ b/cranelift/isle/veri/test-macros/Cargo.toml
@@ -4,6 +4,9 @@ version = "0.1.0"
publish = false
edition.workspace = true
+[lints]
+workspace = true
+
[lib]
proc-macro = true
diff --git a/cranelift/isle/veri/test-macros/src/lib.rs b/cranelift/isle/veri/test-macros/src/lib.rs
index da7a320e2d..d053cb7bea 100644
--- a/cranelift/isle/veri/test-macros/src/lib.rs
+++ b/cranelift/isle/veri/test-macros/src/lib.rs
@@ -1,5 +1,3 @@
-extern crate proc_macro;
-
use std::{env, ffi::OsStr, fs, path::PathBuf, str::FromStr};
use proc_macro::TokenStream;
diff --git a/cranelift/isle/veri/veri/Cargo.toml b/cranelift/isle/veri/veri/Cargo.toml
index 3f9c74ef16..ec4a1ac7f5 100644
--- a/cranelift/isle/veri/veri/Cargo.toml
+++ b/cranelift/isle/veri/veri/Cargo.toml
@@ -4,6 +4,9 @@ version = "0.1.0"
edition.workspace = true
publish = false
+[lints]
+workspace = true
+
[dependencies]
cranelift-isle = { path = "../../isle/", features = ["fancy-errors", "logging"] }
cranelift-isle-veri-caching = { path = "../caching" }
diff --git a/cranelift/isle/veri/veri/src/encoded/cls.rs b/cranelift/isle/veri/veri/src/encoded/cls.rs
index cfd8eafbef..87919646d7 100644
--- a/cranelift/isle/veri/veri/src/encoded/cls.rs
+++ b/cranelift/isle/veri/veri/src/encoded/cls.rs
@@ -11,7 +11,7 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// total zeros counter
let zret0 = declare(
smt,
- format!("zret0_{id}", id = id),
+ format!("zret0_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(
@@ -21,17 +21,17 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 1
let zret1 = declare(
smt,
- format!("zret1_{id}", id = id),
+ format!("zret1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let zy32 = declare(
smt,
- format!("zy32_{id}", id = id),
+ format!("zy32_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let zx32 = declare(
smt,
- format!("zx32_{id}", id = id),
+ format!("zx32_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(zy32, smt.bvlshr(x, smt.atom("#x0000000000000020"))));
@@ -69,17 +69,17 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 2
let zret2 = declare(
smt,
- format!("zret2_{id}", id = id),
+ format!("zret2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let zy16 = declare(
smt,
- format!("zy16_{id}", id = id),
+ format!("zy16_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let zx16 = declare(
smt,
- format!("zx16_{id}", id = id),
+ format!("zx16_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(zy16, smt.bvlshr(zx32, smt.atom("#x0000000000000010"))));
@@ -117,17 +117,17 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 3
let zret3 = declare(
smt,
- format!("zret3_{id}", id = id),
+ format!("zret3_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let zy8 = declare(
smt,
- format!("zy8_{id}", id = id),
+ format!("zy8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let zx8 = declare(
smt,
- format!("zx8_{id}", id = id),
+ format!("zx8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(zy8, smt.bvlshr(zx16, smt.atom("#x0000000000000008"))));
@@ -165,17 +165,17 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 4
let zret4 = declare(
smt,
- format!("zret4_{id}", id = id),
+ format!("zret4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let zy4 = declare(
smt,
- format!("zy4_{id}", id = id),
+ format!("zy4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let zx4 = declare(
smt,
- format!("zx4_{id}", id = id),
+ format!("zx4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(zy4, smt.bvlshr(zx8, smt.atom("#x0000000000000004"))));
@@ -213,17 +213,17 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 5
let zret5 = declare(
smt,
- format!("zret5_{id}", id = id),
+ format!("zret5_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let zy2 = declare(
smt,
- format!("zy2_{id}", id = id),
+ format!("zy2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let zx2 = declare(
smt,
- format!("zx2_{id}", id = id),
+ format!("zx2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(zy2, smt.bvlshr(zx4, smt.atom("#x0000000000000002"))));
@@ -261,17 +261,17 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 6
let zret6 = declare(
smt,
- format!("zret6_{id}", id = id),
+ format!("zret6_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let zy1 = declare(
smt,
- format!("zy1_{id}", id = id),
+ format!("zy1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let zx1 = declare(
smt,
- format!("zx1_{id}", id = id),
+ format!("zx1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(zy1, smt.bvlshr(zx2, smt.atom("#x0000000000000001"))));
@@ -309,7 +309,7 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// last round
let zret7 = declare(
smt,
- format!("zret7_{id}", id = id),
+ format!("zret7_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.list(vec![
@@ -333,7 +333,7 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
]));
let clzret = declare(
smt,
- format!("clzret_{id}", id = id),
+ format!("clzret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.list(vec![
@@ -355,7 +355,7 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// total zeros counter
let sret0 = declare(
smt,
- format!("sret0_{id}", id = id),
+ format!("sret0_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(
@@ -365,17 +365,17 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 1
let sret1 = declare(
smt,
- format!("sret1_{id}", id = id),
+ format!("sret1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let sy32 = declare(
smt,
- format!("sy32_{id}", id = id),
+ format!("sy32_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let sx32 = declare(
smt,
- format!("sx32_{id}", id = id),
+ format!("sx32_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(sy32, smt.bvashr(x, smt.atom("#x0000000000000020"))));
@@ -421,17 +421,17 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 2
let sret2 = declare(
smt,
- format!("sret2_{id}", id = id),
+ format!("sret2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let sy16 = declare(
smt,
- format!("sy16_{id}", id = id),
+ format!("sy16_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let sx16 = declare(
smt,
- format!("sx16_{id}", id = id),
+ format!("sx16_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(sy16, smt.bvashr(sx32, smt.atom("#x0000000000000010"))));
@@ -477,17 +477,17 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 3
let sret3 = declare(
smt,
- format!("sret3_{id}", id = id),
+ format!("sret3_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let sy8 = declare(
smt,
- format!("sy8_{id}", id = id),
+ format!("sy8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let sx8 = declare(
smt,
- format!("sx8_{id}", id = id),
+ format!("sx8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(sy8, smt.bvashr(sx16, smt.atom("#x0000000000000008"))));
@@ -533,17 +533,17 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 4
let sret4 = declare(
smt,
- format!("sret4_{id}", id = id),
+ format!("sret4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let sy4 = declare(
smt,
- format!("sy4_{id}", id = id),
+ format!("sy4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let sx4 = declare(
smt,
- format!("sx4_{id}", id = id),
+ format!("sx4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(sy4, smt.bvashr(sx8, smt.atom("#x0000000000000004"))));
@@ -589,17 +589,17 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 5
let sret5 = declare(
smt,
- format!("sret5_{id}", id = id),
+ format!("sret5_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let sy2 = declare(
smt,
- format!("sy2_{id}", id = id),
+ format!("sy2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let sx2 = declare(
smt,
- format!("sx2_{id}", id = id),
+ format!("sx2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(sy2, smt.bvashr(sx4, smt.atom("#x0000000000000002"))));
@@ -645,17 +645,17 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 6
let sret6 = declare(
smt,
- format!("sret6_{id}", id = id),
+ format!("sret6_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let sy1 = declare(
smt,
- format!("sy1_{id}", id = id),
+ format!("sy1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let sx1 = declare(
smt,
- format!("sx1_{id}", id = id),
+ format!("sx1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(sy1, smt.bvashr(sx2, smt.atom("#x0000000000000001"))));
@@ -701,7 +701,7 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// last round
let sret7 = declare(
smt,
- format!("sret7_{id}", id = id),
+ format!("sret7_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.list(vec![
@@ -729,7 +729,7 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
]));
let clsret = declare(
smt,
- format!("clsret_{id}", id = id),
+ format!("clsret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.list(vec![
@@ -750,7 +750,7 @@ pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
]));
let cls64ret = declare(
smt,
- format!("cls64ret_{id}", id = id),
+ format!("cls64ret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.list(vec![
@@ -774,7 +774,7 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// total zeros counter
let zret0 = declare(
smt,
- format!("zret0_{id}", id = id),
+ format!("zret0_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(
@@ -784,17 +784,17 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 1
let zret2 = declare(
smt,
- format!("zret2_{id}", id = id),
+ format!("zret2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let zy16 = declare(
smt,
- format!("zy16_{id}", id = id),
+ format!("zy16_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let zx16 = declare(
smt,
- format!("zx16_{id}", id = id),
+ format!("zx16_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(zy16, smt.bvlshr(x, smt.atom("#x00000010"))));
@@ -832,17 +832,17 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 2
let zret3 = declare(
smt,
- format!("zret3_{id}", id = id),
+ format!("zret3_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let zy8 = declare(
smt,
- format!("zy8_{id}", id = id),
+ format!("zy8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let zx8 = declare(
smt,
- format!("zx8_{id}", id = id),
+ format!("zx8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(zy8, smt.bvlshr(zx16, smt.atom("#x00000008"))));
@@ -880,17 +880,17 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 3
let zret4 = declare(
smt,
- format!("zret4_{id}", id = id),
+ format!("zret4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let zy4 = declare(
smt,
- format!("zy4_{id}", id = id),
+ format!("zy4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let zx4 = declare(
smt,
- format!("zx4_{id}", id = id),
+ format!("zx4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(zy4, smt.bvlshr(zx8, smt.atom("#x00000004"))));
@@ -928,17 +928,17 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 4
let zret5 = declare(
smt,
- format!("zret5_{id}", id = id),
+ format!("zret5_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let zy2 = declare(
smt,
- format!("zy2_{id}", id = id),
+ format!("zy2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let zx2 = declare(
smt,
- format!("zx2_{id}", id = id),
+ format!("zx2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(zy2, smt.bvlshr(zx4, smt.atom("#x00000002"))));
@@ -976,17 +976,17 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 5
let zret6 = declare(
smt,
- format!("zret6_{id}", id = id),
+ format!("zret6_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let zy1 = declare(
smt,
- format!("zy1_{id}", id = id),
+ format!("zy1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let zx1 = declare(
smt,
- format!("zx1_{id}", id = id),
+ format!("zx1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(zy1, smt.bvlshr(zx2, smt.atom("#x00000001"))));
@@ -1024,7 +1024,7 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// last round
let zret7 = declare(
smt,
- format!("zret7_{id}", id = id),
+ format!("zret7_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.list(vec![
@@ -1048,7 +1048,7 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
]));
let clzret = declare(
smt,
- format!("clzret_{id}", id = id),
+ format!("clzret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.list(vec![
@@ -1070,7 +1070,7 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// total zeros counter
let sret0 = declare(
smt,
- format!("sret0_{id}", id = id),
+ format!("sret0_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(
@@ -1080,17 +1080,17 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 1
let sret2 = declare(
smt,
- format!("sret2_{id}", id = id),
+ format!("sret2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let sy16 = declare(
smt,
- format!("sy16_{id}", id = id),
+ format!("sy16_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let sx16 = declare(
smt,
- format!("sx16_{id}", id = id),
+ format!("sx16_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(sy16, smt.bvashr(x, smt.atom("#x00000010"))));
@@ -1136,17 +1136,17 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 2
let sret3 = declare(
smt,
- format!("sret3_{id}", id = id),
+ format!("sret3_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let sy8 = declare(
smt,
- format!("sy8_{id}", id = id),
+ format!("sy8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let sx8 = declare(
smt,
- format!("sx8_{id}", id = id),
+ format!("sx8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(sy8, smt.bvashr(sx16, smt.atom("#x00000008"))));
@@ -1192,17 +1192,17 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 3
let sret4 = declare(
smt,
- format!("sret4_{id}", id = id),
+ format!("sret4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let sy4 = declare(
smt,
- format!("sy4_{id}", id = id),
+ format!("sy4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let sx4 = declare(
smt,
- format!("sx4_{id}", id = id),
+ format!("sx4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(sy4, smt.bvashr(sx8, smt.atom("#x00000004"))));
@@ -1248,17 +1248,17 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 4
let sret5 = declare(
smt,
- format!("sret5_{id}", id = id),
+ format!("sret5_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let sy2 = declare(
smt,
- format!("sy2_{id}", id = id),
+ format!("sy2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let sx2 = declare(
smt,
- format!("sx2_{id}", id = id),
+ format!("sx2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(sy2, smt.bvashr(sx4, smt.atom("#x00000002"))));
@@ -1304,17 +1304,17 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 5
let sret6 = declare(
smt,
- format!("sret6_{id}", id = id),
+ format!("sret6_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let sy1 = declare(
smt,
- format!("sy1_{id}", id = id),
+ format!("sy1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let sx1 = declare(
smt,
- format!("sx1_{id}", id = id),
+ format!("sx1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(sy1, smt.bvashr(sx2, smt.atom("#x00000001"))));
@@ -1360,7 +1360,7 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// last round
let sret7 = declare(
smt,
- format!("sret7_{id}", id = id),
+ format!("sret7_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.list(vec![
@@ -1388,7 +1388,7 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
]));
let clsret = declare(
smt,
- format!("clsret_{id}", id = id),
+ format!("clsret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.list(vec![
@@ -1409,7 +1409,7 @@ pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
]));
let cls32ret = declare(
smt,
- format!("cls32ret_{id}", id = id),
+ format!("cls32ret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.list(vec![
@@ -1433,7 +1433,7 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// total zeros counter
let zret0 = declare(
smt,
- format!("zret0_{id}", id = id),
+ format!("zret0_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(
@@ -1443,17 +1443,17 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 1
let zret3 = declare(
smt,
- format!("zret3_{id}", id = id),
+ format!("zret3_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let zy8 = declare(
smt,
- format!("zy8_{id}", id = id),
+ format!("zy8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let zx8 = declare(
smt,
- format!("zx8_{id}", id = id),
+ format!("zx8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(zy8, smt.bvlshr(x, smt.atom("#x0008"))));
@@ -1491,17 +1491,17 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 2
let zret4 = declare(
smt,
- format!("zret4_{id}", id = id),
+ format!("zret4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let zy4 = declare(
smt,
- format!("zy4_{id}", id = id),
+ format!("zy4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let zx4 = declare(
smt,
- format!("zx4_{id}", id = id),
+ format!("zx4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(zy4, smt.bvlshr(zx8, smt.atom("#x0004"))));
@@ -1539,17 +1539,17 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 3
let zret5 = declare(
smt,
- format!("zret5_{id}", id = id),
+ format!("zret5_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let zy2 = declare(
smt,
- format!("zy2_{id}", id = id),
+ format!("zy2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let zx2 = declare(
smt,
- format!("zx2_{id}", id = id),
+ format!("zx2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(zy2, smt.bvlshr(zx4, smt.atom("#x0002"))));
@@ -1587,17 +1587,17 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 4
let zret6 = declare(
smt,
- format!("zret6_{id}", id = id),
+ format!("zret6_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let zy1 = declare(
smt,
- format!("zy1_{id}", id = id),
+ format!("zy1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let zx1 = declare(
smt,
- format!("zx1_{id}", id = id),
+ format!("zx1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(zy1, smt.bvlshr(zx2, smt.atom("#x0001"))));
@@ -1635,7 +1635,7 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// last round
let zret7 = declare(
smt,
- format!("zret7_{id}", id = id),
+ format!("zret7_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.list(vec![
@@ -1659,7 +1659,7 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
]));
let clzret = declare(
smt,
- format!("clzret_{id}", id = id),
+ format!("clzret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.list(vec![
@@ -1681,7 +1681,7 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// total zeros counter
let sret0 = declare(
smt,
- format!("sret0_{id}", id = id),
+ format!("sret0_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(
@@ -1691,17 +1691,17 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 1
let sret3 = declare(
smt,
- format!("sret3_{id}", id = id),
+ format!("sret3_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let sy8 = declare(
smt,
- format!("sy8_{id}", id = id),
+ format!("sy8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let sx8 = declare(
smt,
- format!("sx8_{id}", id = id),
+ format!("sx8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(sy8, smt.bvashr(x, smt.atom("#x0008"))));
@@ -1739,17 +1739,17 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 2
let sret4 = declare(
smt,
- format!("sret4_{id}", id = id),
+ format!("sret4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let sy4 = declare(
smt,
- format!("sy4_{id}", id = id),
+ format!("sy4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let sx4 = declare(
smt,
- format!("sx4_{id}", id = id),
+ format!("sx4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(sy4, smt.bvashr(sx8, smt.atom("#x0004"))));
@@ -1787,17 +1787,17 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 3
let sret5 = declare(
smt,
- format!("sret5_{id}", id = id),
+ format!("sret5_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let sy2 = declare(
smt,
- format!("sy2_{id}", id = id),
+ format!("sy2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let sx2 = declare(
smt,
- format!("sx2_{id}", id = id),
+ format!("sx2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(sy2, smt.bvashr(sx4, smt.atom("#x0002"))));
@@ -1835,17 +1835,17 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 4
let sret6 = declare(
smt,
- format!("sret6_{id}", id = id),
+ format!("sret6_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let sy1 = declare(
smt,
- format!("sy1_{id}", id = id),
+ format!("sy1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let sx1 = declare(
smt,
- format!("sx1_{id}", id = id),
+ format!("sx1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(sy1, smt.bvashr(sx2, smt.atom("#x0001"))));
@@ -1883,7 +1883,7 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// last round
let sret7 = declare(
smt,
- format!("sret7_{id}", id = id),
+ format!("sret7_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.list(vec![
@@ -1907,7 +1907,7 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
]));
let clsret = declare(
smt,
- format!("clsret_{id}", id = id),
+ format!("clsret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.list(vec![
@@ -1928,7 +1928,7 @@ pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
]));
let cls16ret = declare(
smt,
- format!("cls16ret_{id}", id = id),
+ format!("cls16ret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.list(vec![
@@ -1952,7 +1952,7 @@ pub fn cls8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// total zeros counter
let zret0 = declare(
smt,
- format!("zret0_{id}", id = id),
+ format!("zret0_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(
@@ -1962,17 +1962,17 @@ pub fn cls8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 1
let zret4 = declare(
smt,
- format!("zret4_{id}", id = id),
+ format!("zret4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let zy4 = declare(
smt,
- format!("zy4_{id}", id = id),
+ format!("zy4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let zx4 = declare(
smt,
- format!("zx4_{id}", id = id),
+ format!("zx4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(zy4, smt.bvlshr(x, smt.atom("#x04"))));
@@ -2010,17 +2010,17 @@ pub fn cls8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 2
let zret5 = declare(
smt,
- format!("zret5_{id}", id = id),
+ format!("zret5_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let zy2 = declare(
smt,
- format!("zy2_{id}", id = id),
+ format!("zy2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let zx2 = declare(
smt,
- format!("zx2_{id}", id = id),
+ format!("zx2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(zy2, smt.bvlshr(zx4, smt.atom("#x02"))));
@@ -2058,17 +2058,17 @@ pub fn cls8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 3
let zret6 = declare(
smt,
- format!("zret6_{id}", id = id),
+ format!("zret6_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let zy1 = declare(
smt,
- format!("zy1_{id}", id = id),
+ format!("zy1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let zx1 = declare(
smt,
- format!("zx1_{id}", id = id),
+ format!("zx1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(zy1, smt.bvlshr(zx2, smt.atom("#x01"))));
@@ -2106,7 +2106,7 @@ pub fn cls8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// last round
let zret7 = declare(
smt,
- format!("zret7_{id}", id = id),
+ format!("zret7_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.list(vec![
@@ -2130,7 +2130,7 @@ pub fn cls8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
]));
let clzret = declare(
smt,
- format!("clzret_{id}", id = id),
+ format!("clzret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.list(vec![
@@ -2152,7 +2152,7 @@ pub fn cls8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// total zeros counter
let sret0 = declare(
smt,
- format!("sret0_{id}", id = id),
+ format!("sret0_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(
@@ -2162,17 +2162,17 @@ pub fn cls8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 1
let sret4 = declare(
smt,
- format!("sret4_{id}", id = id),
+ format!("sret4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let sy4 = declare(
smt,
- format!("sy4_{id}", id = id),
+ format!("sy4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let sx4 = declare(
smt,
- format!("sx4_{id}", id = id),
+ format!("sx4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(sy4, smt.bvashr(x, smt.atom("#x04"))));
@@ -2210,17 +2210,17 @@ pub fn cls8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 2
let sret5 = declare(
smt,
- format!("sret5_{id}", id = id),
+ format!("sret5_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let sy2 = declare(
smt,
- format!("sy2_{id}", id = id),
+ format!("sy2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let sx2 = declare(
smt,
- format!("sx2_{id}", id = id),
+ format!("sx2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(sy2, smt.bvashr(sx4, smt.atom("#x02"))));
@@ -2258,17 +2258,17 @@ pub fn cls8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 3
let sret6 = declare(
smt,
- format!("sret6_{id}", id = id),
+ format!("sret6_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let sy1 = declare(
smt,
- format!("sy1_{id}", id = id),
+ format!("sy1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let sx1 = declare(
smt,
- format!("sx1_{id}", id = id),
+ format!("sx1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(sy1, smt.bvashr(sx2, smt.atom("#x01"))));
@@ -2306,7 +2306,7 @@ pub fn cls8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// last round
let sret7 = declare(
smt,
- format!("sret7_{id}", id = id),
+ format!("sret7_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.list(vec![
@@ -2330,7 +2330,7 @@ pub fn cls8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
]));
let clsret = declare(
smt,
- format!("clsret_{id}", id = id),
+ format!("clsret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.list(vec![
@@ -2351,7 +2351,7 @@ pub fn cls8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
]));
let cls8ret = declare(
smt,
- format!("cls8ret_{id}", id = id),
+ format!("cls8ret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.list(vec![
@@ -2372,7 +2372,7 @@ pub fn cls1(smt: &mut Context, id: usize) -> SExpr {
// Generated code.
let cls1ret = declare(
smt,
- format!("cls1ret_{id}", id = id),
+ format!("cls1ret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(1)]),
);
let _ = smt.assert(smt.eq(
diff --git a/cranelift/isle/veri/veri/src/encoded/clz.rs b/cranelift/isle/veri/veri/src/encoded/clz.rs
index 6aaf257fa0..d724de8ca3 100644
--- a/cranelift/isle/veri/veri/src/encoded/clz.rs
+++ b/cranelift/isle/veri/veri/src/encoded/clz.rs
@@ -11,7 +11,7 @@ pub fn clz64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// total zeros counter
let ret0 = declare(
smt,
- format!("ret0_{id}", id = id),
+ format!("ret0_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(
@@ -21,17 +21,17 @@ pub fn clz64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 1
let ret1 = declare(
smt,
- format!("ret1_{id}", id = id),
+ format!("ret1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let y32 = declare(
smt,
- format!("y32_{id}", id = id),
+ format!("y32_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let x32 = declare(
smt,
- format!("x32_{id}", id = id),
+ format!("x32_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(y32, smt.bvlshr(x, smt.atom("#x0000000000000020"))));
@@ -69,17 +69,17 @@ pub fn clz64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 2
let ret2 = declare(
smt,
- format!("ret2_{id}", id = id),
+ format!("ret2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let y16 = declare(
smt,
- format!("y16_{id}", id = id),
+ format!("y16_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let x16 = declare(
smt,
- format!("x16_{id}", id = id),
+ format!("x16_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(y16, smt.bvlshr(x32, smt.atom("#x0000000000000010"))));
@@ -117,17 +117,17 @@ pub fn clz64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 3
let ret3 = declare(
smt,
- format!("ret3_{id}", id = id),
+ format!("ret3_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let y8 = declare(
smt,
- format!("y8_{id}", id = id),
+ format!("y8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let x8 = declare(
smt,
- format!("x8_{id}", id = id),
+ format!("x8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(y8, smt.bvlshr(x16, smt.atom("#x0000000000000008"))));
@@ -165,17 +165,17 @@ pub fn clz64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 4
let ret4 = declare(
smt,
- format!("ret4_{id}", id = id),
+ format!("ret4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let y4 = declare(
smt,
- format!("y4_{id}", id = id),
+ format!("y4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let x4 = declare(
smt,
- format!("x4_{id}", id = id),
+ format!("x4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(y4, smt.bvlshr(x8, smt.atom("#x0000000000000004"))));
@@ -213,17 +213,17 @@ pub fn clz64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 5
let ret5 = declare(
smt,
- format!("ret5_{id}", id = id),
+ format!("ret5_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let y2 = declare(
smt,
- format!("y2_{id}", id = id),
+ format!("y2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let x2 = declare(
smt,
- format!("x2_{id}", id = id),
+ format!("x2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(y2, smt.bvlshr(x4, smt.atom("#x0000000000000002"))));
@@ -261,17 +261,17 @@ pub fn clz64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 6
let ret6 = declare(
smt,
- format!("ret6_{id}", id = id),
+ format!("ret6_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let y1 = declare(
smt,
- format!("y1_{id}", id = id),
+ format!("y1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let x1 = declare(
smt,
- format!("x1_{id}", id = id),
+ format!("x1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(y1, smt.bvlshr(x2, smt.atom("#x0000000000000001"))));
@@ -310,7 +310,7 @@ pub fn clz64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// last round
let ret7 = declare(
smt,
- format!("ret7_{id}", id = id),
+ format!("ret7_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.list(vec![
@@ -343,7 +343,7 @@ pub fn clz32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// total zeros counter
let ret0 = declare(
smt,
- format!("ret0_{id}", id = id),
+ format!("ret0_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(
@@ -353,17 +353,17 @@ pub fn clz32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 1
let ret1 = declare(
smt,
- format!("ret1_{id}", id = id),
+ format!("ret1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let y16 = declare(
smt,
- format!("y16_{id}", id = id),
+ format!("y16_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let x16 = declare(
smt,
- format!("x16_{id}", id = id),
+ format!("x16_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(y16, smt.bvlshr(x, smt.atom("#x00000010"))));
@@ -401,17 +401,17 @@ pub fn clz32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 2
let ret2 = declare(
smt,
- format!("ret2_{id}", id = id),
+ format!("ret2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let y8 = declare(
smt,
- format!("y8_{id}", id = id),
+ format!("y8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let x8 = declare(
smt,
- format!("x8_{id}", id = id),
+ format!("x8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(y8, smt.bvlshr(x16, smt.atom("#x00000008"))));
@@ -449,17 +449,17 @@ pub fn clz32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 3
let ret3 = declare(
smt,
- format!("ret3_{id}", id = id),
+ format!("ret3_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let y4 = declare(
smt,
- format!("y4_{id}", id = id),
+ format!("y4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let x4 = declare(
smt,
- format!("x4_{id}", id = id),
+ format!("x4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(y4, smt.bvlshr(x8, smt.atom("#x00000004"))));
@@ -497,17 +497,17 @@ pub fn clz32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 4
let ret4 = declare(
smt,
- format!("ret4_{id}", id = id),
+ format!("ret4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let y2 = declare(
smt,
- format!("y2_{id}", id = id),
+ format!("y2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let x2 = declare(
smt,
- format!("x2_{id}", id = id),
+ format!("x2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(y2, smt.bvlshr(x4, smt.atom("#x00000002"))));
@@ -545,17 +545,17 @@ pub fn clz32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 5
let ret5 = declare(
smt,
- format!("ret5_{id}", id = id),
+ format!("ret5_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let y1 = declare(
smt,
- format!("y1_{id}", id = id),
+ format!("y1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let x1 = declare(
smt,
- format!("x1_{id}", id = id),
+ format!("x1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(y1, smt.bvlshr(x2, smt.atom("#x00000001"))));
@@ -594,7 +594,7 @@ pub fn clz32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// last round
let ret6 = declare(
smt,
- format!("ret6_{id}", id = id),
+ format!("ret6_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.list(vec![
@@ -626,7 +626,7 @@ pub fn clz16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// total zeros counter
let ret1 = declare(
smt,
- format!("ret1_{id}", id = id),
+ format!("ret1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(
@@ -636,17 +636,17 @@ pub fn clz16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 1
let ret2 = declare(
smt,
- format!("ret2_{id}", id = id),
+ format!("ret2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let y8 = declare(
smt,
- format!("y8_{id}", id = id),
+ format!("y8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let x8 = declare(
smt,
- format!("x8_{id}", id = id),
+ format!("x8_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(y8, smt.bvlshr(x, smt.atom("#x0008"))));
@@ -684,17 +684,17 @@ pub fn clz16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 2
let ret3 = declare(
smt,
- format!("ret3_{id}", id = id),
+ format!("ret3_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let y4 = declare(
smt,
- format!("y4_{id}", id = id),
+ format!("y4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let x4 = declare(
smt,
- format!("x4_{id}", id = id),
+ format!("x4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(y4, smt.bvlshr(x8, smt.atom("#x0004"))));
@@ -732,17 +732,17 @@ pub fn clz16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 3
let ret4 = declare(
smt,
- format!("ret4_{id}", id = id),
+ format!("ret4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let y2 = declare(
smt,
- format!("y2_{id}", id = id),
+ format!("y2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let x2 = declare(
smt,
- format!("x2_{id}", id = id),
+ format!("x2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(y2, smt.bvlshr(x4, smt.atom("#x0002"))));
@@ -780,17 +780,17 @@ pub fn clz16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 4
let ret5 = declare(
smt,
- format!("ret5_{id}", id = id),
+ format!("ret5_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let y1 = declare(
smt,
- format!("y1_{id}", id = id),
+ format!("y1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let x1 = declare(
smt,
- format!("x1_{id}", id = id),
+ format!("x1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(y1, smt.bvlshr(x2, smt.atom("#x0001"))));
@@ -829,7 +829,7 @@ pub fn clz16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// last round
let ret6 = declare(
smt,
- format!("ret6_{id}", id = id),
+ format!("ret6_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.list(vec![
@@ -861,7 +861,7 @@ pub fn clz8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// total zeros counter
let ret0 = declare(
smt,
- format!("ret0_{id}", id = id),
+ format!("ret0_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(
@@ -871,17 +871,17 @@ pub fn clz8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 1
let ret3 = declare(
smt,
- format!("ret3_{id}", id = id),
+ format!("ret3_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let y4 = declare(
smt,
- format!("y4_{id}", id = id),
+ format!("y4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let x4 = declare(
smt,
- format!("x4_{id}", id = id),
+ format!("x4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(y4, smt.bvlshr(x, smt.atom("#x04"))));
@@ -919,17 +919,17 @@ pub fn clz8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 2
let ret4 = declare(
smt,
- format!("ret4_{id}", id = id),
+ format!("ret4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let y2 = declare(
smt,
- format!("y2_{id}", id = id),
+ format!("y2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let x2 = declare(
smt,
- format!("x2_{id}", id = id),
+ format!("x2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(y2, smt.bvlshr(x4, smt.atom("#x02"))));
@@ -967,17 +967,17 @@ pub fn clz8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// round 3
let ret5 = declare(
smt,
- format!("ret5_{id}", id = id),
+ format!("ret5_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let y1 = declare(
smt,
- format!("y1_{id}", id = id),
+ format!("y1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let x1 = declare(
smt,
- format!("x1_{id}", id = id),
+ format!("x1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(y1, smt.bvlshr(x2, smt.atom("#x01"))));
@@ -1015,7 +1015,7 @@ pub fn clz8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// last round
let ret6 = declare(
smt,
- format!("ret6_{id}", id = id),
+ format!("ret6_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.list(vec![
@@ -1047,7 +1047,7 @@ pub fn clz1(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// Generated code.
let clz1ret = declare(
smt,
- format!("clz1ret_{id}", id = id),
+ format!("clz1ret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(1)]),
);
let _ = smt.assert(smt.eq(clz1ret, smt.list(vec![smt.atom("bvnot"), x])));
diff --git a/cranelift/isle/veri/veri/src/encoded/rev.rs b/cranelift/isle/veri/veri/src/encoded/rev.rs
index e1433542d7..3ad9072780 100644
--- a/cranelift/isle/veri/veri/src/encoded/rev.rs
+++ b/cranelift/isle/veri/veri/src/encoded/rev.rs
@@ -9,7 +9,7 @@ pub fn rev64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// Generated code.
let x1 = declare(
smt,
- format!("x1_{id}", id = id),
+ format!("x1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(
@@ -21,7 +21,7 @@ pub fn rev64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
));
let x2 = declare(
smt,
- format!("x2_{id}", id = id),
+ format!("x2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(
@@ -39,7 +39,7 @@ pub fn rev64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
));
let x3 = declare(
smt,
- format!("x3_{id}", id = id),
+ format!("x3_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(
@@ -57,7 +57,7 @@ pub fn rev64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
));
let x4 = declare(
smt,
- format!("x4_{id}", id = id),
+ format!("x4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(
@@ -75,7 +75,7 @@ pub fn rev64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
));
let x5 = declare(
smt,
- format!("x5_{id}", id = id),
+ format!("x5_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(
@@ -93,7 +93,7 @@ pub fn rev64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
));
let rev64ret = declare(
smt,
- format!("rev64ret_{id}", id = id),
+ format!("rev64ret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
);
let _ = smt.assert(smt.eq(
@@ -119,7 +119,7 @@ pub fn rev32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// Generated code.
let x1 = declare(
smt,
- format!("x1_{id}", id = id),
+ format!("x1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(
@@ -131,7 +131,7 @@ pub fn rev32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
));
let x2 = declare(
smt,
- format!("x2_{id}", id = id),
+ format!("x2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(
@@ -149,7 +149,7 @@ pub fn rev32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
));
let x3 = declare(
smt,
- format!("x3_{id}", id = id),
+ format!("x3_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(
@@ -167,7 +167,7 @@ pub fn rev32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
));
let x4 = declare(
smt,
- format!("x4_{id}", id = id),
+ format!("x4_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(
@@ -185,7 +185,7 @@ pub fn rev32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
));
let rev32ret = declare(
smt,
- format!("rev32ret_{id}", id = id),
+ format!("rev32ret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
);
let _ = smt.assert(smt.eq(
@@ -211,7 +211,7 @@ pub fn rev16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// Generated code.
let x1 = declare(
smt,
- format!("x1_{id}", id = id),
+ format!("x1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(
@@ -223,7 +223,7 @@ pub fn rev16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
));
let x2 = declare(
smt,
- format!("x2_{id}", id = id),
+ format!("x2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(
@@ -235,7 +235,7 @@ pub fn rev16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
));
let x3 = declare(
smt,
- format!("x3_{id}", id = id),
+ format!("x3_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(
@@ -247,7 +247,7 @@ pub fn rev16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
));
let rev16ret = declare(
smt,
- format!("rev16ret_{id}", id = id),
+ format!("rev16ret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
);
let _ = smt.assert(smt.eq(
@@ -269,7 +269,7 @@ pub fn rev8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// Generated code.
let x1 = declare(
smt,
- format!("x1_{id}", id = id),
+ format!("x1_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(
@@ -281,7 +281,7 @@ pub fn rev8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
));
let x2 = declare(
smt,
- format!("x2_{id}", id = id),
+ format!("x2_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(
@@ -293,7 +293,7 @@ pub fn rev8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
));
let rev8ret = declare(
smt,
- format!("rev8ret_{id}", id = id),
+ format!("rev8ret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
);
let _ = smt.assert(smt.eq(
@@ -315,7 +315,7 @@ pub fn rev1(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
// Generated code.
let rev1ret = declare(
smt,
- format!("rev1ret_{id}", id = id),
+ format!("rev1ret_{id}"),
smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(1)]),
);
let _ = smt.assert(smt.eq(rev1ret, x));
diff --git a/cranelift/isle/veri/veri/src/runner.rs b/cranelift/isle/veri/veri/src/runner.rs
index 4f31bb11a2..fb17e5ce4c 100644
--- a/cranelift/isle/veri/veri/src/runner.rs
+++ b/cranelift/isle/veri/veri/src/runner.rs
@@ -230,7 +230,7 @@ impl SolverRule {
/// Build a rule that selects the solver backend for expansions with an
/// explicit `solver_<name>` tag.
fn solver_tag(solver_backend: SolverBackend) -> Self {
- let tag = format!("solver_{}", solver_backend);
+ let tag = format!("solver_{solver_backend}");
Self {
predicate: ExpansionPredicate::Tagged(tag),
solver_backend,
@@ -769,7 +769,7 @@ impl Runner {
// expansion that has no spec) is recorded and reported rather
// than aborting the whole run, so that one un-verifiable
// expansion does not hide coverage of all the others.
- let expansion_log_dir = self.log_dir.join("expansions").join(format!("{:05}", i));
+ let expansion_log_dir = self.log_dir.join("expansions").join(format!("{i:05}"));
match self.verify_expansion(expansion, i, expansion_log_dir.clone(), &failures) {
Ok(report) => Ok(Some(report)),
Err(err) => {
@@ -1296,7 +1296,7 @@ impl Runner {
continue;
}
- let solution_log_dir = log_dir.join(format!("{:03}", i));
+ let solution_log_dir = log_dir.join(format!("{i:03}"));
let verify_report = self
.verify_expansion_type_instantiation(
&conditions,
diff --git a/cranelift/isle/veri/veri/src/spec.rs b/cranelift/isle/veri/veri/src/spec.rs
index 0b5988cbd3..195756884d 100644
--- a/cranelift/isle/veri/veri/src/spec.rs
+++ b/cranelift/isle/veri/veri/src/spec.rs
@@ -944,11 +944,7 @@ impl SpecEnv {
}
// Extractor
- if term.has_extractor() {
- return true;
- }
-
- false
+ term.has_extractor()
}
fn check_for_chained_terms_with_spec(&self) {
diff --git a/cranelift/isle/veri/veri/src/veri.rs b/cranelift/isle/veri/veri/src/veri.rs
index ed821bc45a..ecd6e55979 100644
--- a/cranelift/isle/veri/veri/src/veri.rs
+++ b/cranelift/isle/veri/veri/src/veri.rs
@@ -837,7 +837,7 @@ impl Conditions {
if !call.args.is_empty() {
println!("\t\t\targs = [");
for arg in &call.args {
- println!("\t\t\t\t{}", arg);
+ println!("\t\t\t\t{arg}");
}
println!("\t\t\t]");
}
diff --git a/cranelift/jit/Cargo.toml b/cranelift/jit/Cargo.toml
index 96687f5473..5b23e851ab 100644
--- a/cranelift/jit/Cargo.toml
+++ b/cranelift/jit/Cargo.toml
@@ -6,7 +6,6 @@ description = "A JIT library backed by Cranelift"
repository = "https://github.com/bytecodealliance/wasmtime"
documentation = "https://docs.rs/cranelift-jit"
license = "Apache-2.0 WITH LLVM-exception"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
diff --git a/cranelift/module/Cargo.toml b/cranelift/module/Cargo.toml
index cfbaba5b2e..7fac1949af 100644
--- a/cranelift/module/Cargo.toml
+++ b/cranelift/module/Cargo.toml
@@ -7,7 +7,6 @@ repository = "https://github.com/bytecodealliance/wasmtime"
documentation = "https://docs.rs/cranelift-module"
categories = ["no-std"]
license = "Apache-2.0 WITH LLVM-exception"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
diff --git a/cranelift/native/Cargo.toml b/cranelift/native/Cargo.toml
index 55c53b4db6..0acad25aed 100644
--- a/cranelift/native/Cargo.toml
+++ b/cranelift/native/Cargo.toml
@@ -7,10 +7,12 @@ documentation = "https://docs.rs/cranelift-native"
repository = "https://github.com/bytecodealliance/wasmtime"
categories = ["no-std"]
license = "Apache-2.0 WITH LLVM-exception"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
+[lints]
+workspace = true
+
[dependencies]
cranelift-codegen = { workspace = true }
target-lexicon = { workspace = true }
diff --git a/cranelift/object/Cargo.toml b/cranelift/object/Cargo.toml
index 8d83ec9bb5..cd45cb97a7 100644
--- a/cranelift/object/Cargo.toml
+++ b/cranelift/object/Cargo.toml
@@ -6,7 +6,6 @@ description = "Emit Cranelift output to native object files with `object`"
repository = "https://github.com/bytecodealliance/wasmtime"
documentation = "https://docs.rs/cranelift-object"
license = "Apache-2.0 WITH LLVM-exception"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
diff --git a/cranelift/reader/Cargo.toml b/cranelift/reader/Cargo.toml
index eeea6fad7a..2b1c0d3e83 100644
--- a/cranelift/reader/Cargo.toml
+++ b/cranelift/reader/Cargo.toml
@@ -6,7 +6,6 @@ description = "Cranelift textual IR reader"
license = "Apache-2.0 WITH LLVM-exception"
documentation = "https://docs.rs/cranelift-reader"
repository = "https://github.com/bytecodealliance/wasmtime"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
diff --git a/cranelift/serde/Cargo.toml b/cranelift/serde/Cargo.toml
index 729dc1f876..01c43391b6 100644
--- a/cranelift/serde/Cargo.toml
+++ b/cranelift/serde/Cargo.toml
@@ -5,7 +5,6 @@ authors = ["The Cranelift Project Developers"]
description = "Serializer/Deserializer for Cranelift IR"
repository = "https://github.com/bytecodealliance/wasmtime"
license = "Apache-2.0 WITH LLVM-exception"
-readme = "README.md"
keywords = ["webassembly", "serde"]
edition.workspace = true
rust-version.workspace = true
diff --git a/cranelift/umbrella/Cargo.toml b/cranelift/umbrella/Cargo.toml
index f67a2e0cbe..1899ddd152 100644
--- a/cranelift/umbrella/Cargo.toml
+++ b/cranelift/umbrella/Cargo.toml
@@ -7,11 +7,13 @@ license = "Apache-2.0 WITH LLVM-exception"
documentation = "https://docs.rs/cranelift"
repository = "https://github.com/bytecodealliance/wasmtime"
categories = ["no-std"]
-readme = "README.md"
keywords = ["compile", "compiler", "jit"]
edition.workspace = true
rust-version.workspace = true
+[lints]
+workspace = true
+
[dependencies]
cranelift-codegen = { workspace = true }
cranelift-frontend = { workspace = true, optional = true }
diff --git a/crates/c-api/Cargo.toml b/crates/c-api/Cargo.toml
index 5cbcae521d..3c1318d2df 100644
--- a/crates/c-api/Cargo.toml
+++ b/crates/c-api/Cargo.toml
@@ -5,7 +5,6 @@ authors.workspace = true
description = "C API to expose the Wasmtime runtime"
license = "Apache-2.0 WITH LLVM-exception"
repository = "https://github.com/bytecodealliance/wasmtime"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
links = "wasmtime-c-api"
diff --git a/crates/c-api/artifact/Cargo.toml b/crates/c-api/artifact/Cargo.toml
index 026f0816ac..63cae9f6b2 100644
--- a/crates/c-api/artifact/Cargo.toml
+++ b/crates/c-api/artifact/Cargo.toml
@@ -10,6 +10,9 @@ edition.workspace = true
rust-version.workspace = true
publish = false
+[lints]
+workspace = true
+
[lib]
name = "wasmtime"
crate-type = ["staticlib", "cdylib"]
diff --git a/crates/component-util/Cargo.toml b/crates/component-util/Cargo.toml
index b6b3a3c0ed..7c7a4f1537 100644
--- a/crates/component-util/Cargo.toml
+++ b/crates/component-util/Cargo.toml
@@ -10,3 +10,6 @@ categories = ["wasm"]
keywords = ["webassembly", "wasm"]
edition.workspace = true
rust-version.workspace = true
+
+[lints]
+workspace = true
diff --git a/crates/environ/fuzz/Cargo.toml b/crates/environ/fuzz/Cargo.toml
index 026f741b88..589affe4c1 100644
--- a/crates/environ/fuzz/Cargo.toml
+++ b/crates/environ/fuzz/Cargo.toml
@@ -9,6 +9,9 @@ rust-version.workspace = true
[package.metadata]
cargo-fuzz = true
+[lints]
+workspace = true
+
[dependencies]
arbitrary = { workspace = true, features = ["derive"] }
env_logger = { workspace = true }
diff --git a/crates/jit-debug/Cargo.toml b/crates/jit-debug/Cargo.toml
index 059a2c4a2d..6d74a979a8 100644
--- a/crates/jit-debug/Cargo.toml
+++ b/crates/jit-debug/Cargo.toml
@@ -7,7 +7,6 @@ license = "Apache-2.0 WITH LLVM-exception"
categories = ["development-tools::debugging"]
keywords = ["gdb", "jit"]
repository = "https://github.com/bytecodealliance/wasmtime"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
diff --git a/crates/misc/component-async-tests/Cargo.toml b/crates/misc/component-async-tests/Cargo.toml
index f24013a71f..1a6f1c406d 100644
--- a/crates/misc/component-async-tests/Cargo.toml
+++ b/crates/misc/component-async-tests/Cargo.toml
@@ -12,7 +12,6 @@ workspace = true
[dependencies]
futures = { workspace = true, features = ['async-await'] }
-env_logger = { workspace = true }
tempfile = { workspace = true }
tokio = { workspace = true, features = [
"fs",
@@ -32,6 +31,7 @@ wasmtime = { workspace = true, features = [
wasmtime-wasi = { workspace = true }
[dev-dependencies]
+env_logger = { workspace = true }
wasm-compose = { workspace = true }
test-programs-artifacts = { workspace = true }
bytes = { workspace = true }
diff --git a/crates/test-programs/Cargo.toml b/crates/test-programs/Cargo.toml
index 884df08464..9f4cff2784 100644
--- a/crates/test-programs/Cargo.toml
+++ b/crates/test-programs/Cargo.toml
@@ -21,6 +21,5 @@ sha2 = { workspace = true }
base64 = { workspace = true }
wasip1 = { version = "1.0.0", default-features = true }
wasip2 = "1.0.0"
-once_cell = "1.19.0"
flate2 = "1.0.28"
regex = { workspace = true }
diff --git a/crates/unwinder/Cargo.toml b/crates/unwinder/Cargo.toml
index 889ad47efc..b5b8110479 100644
--- a/crates/unwinder/Cargo.toml
+++ b/crates/unwinder/Cargo.toml
@@ -7,7 +7,6 @@ license = "Apache-2.0 WITH LLVM-exception"
documentation = "https://docs.rs/wasmtime-unwinder"
repository = "https://github.com/bytecodealliance/wasmtime"
categories = ["no-std"]
-readme = "README.md"
keywords = ["unwind", "exceptions"]
edition.workspace = true
rust-version.workspace = true
diff --git a/crates/versioned-export-macros/Cargo.toml b/crates/versioned-export-macros/Cargo.toml
index 457a56b350..0cd6dc8eb6 100644
--- a/crates/versioned-export-macros/Cargo.toml
+++ b/crates/versioned-export-macros/Cargo.toml
@@ -8,7 +8,8 @@ name = "wasmtime-internal-versioned-export-macros"
repository = "https://github.com/bytecodealliance/wasmtime"
version.workspace = true
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lints]
+workspace = true
[dependencies]
syn = { workspace = true, features = ["full"] }
diff --git a/crates/versioned-export-macros/src/lib.rs b/crates/versioned-export-macros/src/lib.rs
index 2fb613dc29..1793b37428 100644
--- a/crates/versioned-export-macros/src/lib.rs
+++ b/crates/versioned-export-macros/src/lib.rs
@@ -18,7 +18,7 @@ fn version(value: impl std::fmt::Display) -> String {
.chars()
.map(|c| if c.is_ascii_alphanumeric() { c } else { '_' })
.collect();
- format!("{}_{}", value, version)
+ format!("{value}_{version}")
}
fn versioned_lit_str(value: impl std::fmt::Display) -> syn::LitStr {
diff --git a/crates/wasi-nn/Cargo.toml b/crates/wasi-nn/Cargo.toml
index e787a5f00a..ecfd388470 100644
--- a/crates/wasi-nn/Cargo.toml
+++ b/crates/wasi-nn/Cargo.toml
@@ -8,7 +8,6 @@ license = "Apache-2.0 WITH LLVM-exception"
categories = ["wasm", "computer-vision"]
keywords = ["webassembly", "wasm", "neural-network"]
repository = "https://github.com/bytecodealliance/wasmtime"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
diff --git a/crates/wasi-preview1-component-adapter/byte-array-literals/Cargo.toml b/crates/wasi-preview1-component-adapter/byte-array-literals/Cargo.toml
index 10b21a963f..3650a00f78 100644
--- a/crates/wasi-preview1-component-adapter/byte-array-literals/Cargo.toml
+++ b/crates/wasi-preview1-component-adapter/byte-array-literals/Cargo.toml
@@ -6,6 +6,9 @@ edition.workspace = true
rust-version.workspace = true
publish = false
+[lints]
+workspace = true
+
[lib]
proc-macro = true
test = false
diff --git a/crates/wasi-preview1-component-adapter/byte-array-literals/src/lib.rs b/crates/wasi-preview1-component-adapter/byte-array-literals/src/lib.rs
index ea9f013d9f..4f32d1b5e5 100644
--- a/crates/wasi-preview1-component-adapter/byte-array-literals/src/lib.rs
+++ b/crates/wasi-preview1-component-adapter/byte-array-literals/src/lib.rs
@@ -1,5 +1,3 @@
-extern crate proc_macro;
-
use proc_macro::{Delimiter, Group, Literal, Punct, Spacing, TokenStream, TokenTree};
/// Expand a `str` literal into a byte array.
diff --git a/crates/wasi/Cargo.toml b/crates/wasi/Cargo.toml
index fcf250429f..43020d9d07 100644
--- a/crates/wasi/Cargo.toml
+++ b/crates/wasi/Cargo.toml
@@ -7,7 +7,6 @@ license = "Apache-2.0 WITH LLVM-exception"
categories = ["wasm"]
keywords = ["webassembly", "wasm"]
repository = "https://github.com/bytecodealliance/wasmtime"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
include = ["src/**/*", "README.md", "LICENSE", "witx/*", "wit/**/*", "tests/*"]
diff --git a/crates/wasmtime/Cargo.toml b/crates/wasmtime/Cargo.toml
index 2ee8eb451b..5bbbb645f2 100644
--- a/crates/wasmtime/Cargo.toml
+++ b/crates/wasmtime/Cargo.toml
@@ -6,16 +6,15 @@ description = "High-level API to expose the Wasmtime runtime"
documentation = "https://docs.rs/wasmtime"
license = "Apache-2.0 WITH LLVM-exception"
repository = "https://github.com/bytecodealliance/wasmtime"
-readme = "README.md"
edition.workspace = true
rust-version.workspace = true
-[lints]
-workspace = true
-
[package.metadata.docs.rs]
all-features = true
+[lints]
+workspace = true
+
[dependencies]
wasmtime-environ = { workspace = true }
wasmtime-jit-debug = { workspace = true, optional = true }
diff --git a/crates/wiggle/generate/Cargo.toml b/crates/wiggle/generate/Cargo.toml
index 6b47defbe5..15c6ea01c9 100644
--- a/crates/wiggle/generate/Cargo.toml
+++ b/crates/wiggle/generate/Cargo.toml
@@ -9,7 +9,6 @@ description = "Library crate for wiggle code generator."
categories = ["wasm"]
keywords = ["webassembly", "wasm"]
repository = "https://github.com/bytecodealliance/wasmtime"
-readme = "README.md"
include = ["src/**/*", "README.md", "LICENSE"]
[lints]
diff --git a/crates/wizer/fuzz/Cargo.toml b/crates/wizer/fuzz/Cargo.toml
index 23b9c6158b..13c9d367fe 100644
--- a/crates/wizer/fuzz/Cargo.toml
+++ b/crates/wizer/fuzz/Cargo.toml
@@ -21,7 +21,7 @@ wasmtime = { workspace = true }
wasmtime-wizer = { workspace = true, features = ["wasmtime"] }
[[bin]]
-name = "same_result"
-path = "fuzz_targets/same_result.rs"
+name = "same-result"
+path = "fuzz_targets/same-result.rs"
test = false
doc = false
diff --git a/crates/wizer/fuzz/fuzz_targets/same_result.rs b/crates/wizer/fuzz/fuzz_targets/same-result.rs
similarity index 100%
rename from crates/wizer/fuzz/fuzz_targets/same_result.rs
rename to crates/wizer/fuzz/fuzz_targets/same-result.rs
diff --git a/examples/component/wasm/Cargo.toml b/examples/component/wasm/Cargo.toml
index d3380f5120..44291833d4 100644
--- a/examples/component/wasm/Cargo.toml
+++ b/examples/component/wasm/Cargo.toml
@@ -5,6 +5,9 @@ authors = ["The Wasmtime Project Developers"]
edition = "2021"
publish = false
+[lints]
+workspace = true
+
[dependencies]
wit-bindgen = { workspace = true, default-features = true }
diff --git a/examples/resource-component/wasm/Cargo.toml b/examples/resource-component/wasm/Cargo.toml
index 20b30228d8..d0d036b79e 100644
--- a/examples/resource-component/wasm/Cargo.toml
+++ b/examples/resource-component/wasm/Cargo.toml
@@ -5,6 +5,9 @@ authors = ["The Wasmtime Project Developers"]
edition = "2024"
publish = false
+[lints]
+workspace = true
+
[dependencies]
wit-bindgen = { workspace = true, default-features = true }
diff --git a/examples/tokio/wasm/Cargo.toml b/examples/tokio/wasm/Cargo.toml
index 44894a82af..55a31c0fa4 100644
--- a/examples/tokio/wasm/Cargo.toml
+++ b/examples/tokio/wasm/Cargo.toml
@@ -5,6 +5,9 @@ authors = ["The Wasmtime Project Developers"]
edition = "2021"
publish = false
+[lints]
+workspace = true
+
[[bin]]
path = "tokio-wasi.rs"
name = "tokio-wasi"
diff --git a/examples/wasip2-plugins/Cargo.toml b/examples/wasip2-plugins/Cargo.toml
index cce35e7b78..3bfe644a94 100644
--- a/examples/wasip2-plugins/Cargo.toml
+++ b/examples/wasip2-plugins/Cargo.toml
@@ -8,10 +8,12 @@ with plugins for arithmetic operations.
"""
publish = false
+[lints]
+workspace = true
+
[dependencies]
clap = { workspace = true, features = ["derive"] }
-wasmtime = { workspace = true, features = ['std', 'cranelift'] }
-wasmtime-wasi = { workspace = true }
+wasmtime = { workspace = true, features = ['default'] }
[features]
build-plugins = []
diff --git a/examples/wasip2-plugins/build.rs b/examples/wasip2-plugins/build.rs
index 7cdff827b8..28b5c7f616 100644
--- a/examples/wasip2-plugins/build.rs
+++ b/examples/wasip2-plugins/build.rs
@@ -3,7 +3,7 @@ use std::path::Path;
use std::process::Command;
use std::process::exit;
-#[allow(dead_code)]
+#[allow(dead_code, reason = "not worth cfgs")]
fn build_c_plugin() {
// Run wit-bindgen
let mut status = Command::new("wit-bindgen")
@@ -12,10 +12,7 @@ fn build_c_plugin() {
.status()
.expect("wit-bindgen c ../wit/calculator.wit failed (cwd = c-plugin)");
if !status.success() {
- println!(
- "wit-bindgen c ../wit/calculator.wit failed (cwd = c-plugin): status {}",
- status
- );
+ println!("wit-bindgen c ../wit/calculator.wit failed (cwd = c-plugin): status {status}");
exit(1);
}
@@ -54,7 +51,7 @@ fn build_c_plugin() {
}
}
-#[allow(dead_code)]
+#[allow(dead_code, reason = "not worth cfgs")]
fn build_js_plugin() {
Command::new("jco")
.args([
diff --git a/examples/wasip2-plugins/src/main.rs b/examples/wasip2-plugins/src/main.rs
index 40814411e6..564f41cea9 100644
--- a/examples/wasip2-plugins/src/main.rs
+++ b/examples/wasip2-plugins/src/main.rs
@@ -71,7 +71,7 @@ fn load_plugin(
linker: &Linker<()>,
path: PathBuf,
) -> wasmtime::Result<()> {
- println!("Loading plugin from file {:?}", path);
+ println!("Loading plugin from file {path:?}");
// Creates a component from a .wasm file
let component = Component::from_file(engine, &path)?;
diff --git a/examples/wasm/Cargo.toml b/examples/wasm/Cargo.toml
index b8c0225881..e1ad44c3d8 100644
--- a/examples/wasm/Cargo.toml
+++ b/examples/wasm/Cargo.toml
@@ -5,6 +5,9 @@ authors = ["The Wasmtime Project Developers"]
edition = "2021"
publish = false
+[lints]
+workspace = true
+
[[bin]]
path = "wasi.rs"
name = "wasi"
diff --git a/pulley/macros/Cargo.toml b/pulley/macros/Cargo.toml
index 70b336c57d..78c8f9f8eb 100644
--- a/pulley/macros/Cargo.toml
+++ b/pulley/macros/Cargo.toml
@@ -7,6 +7,9 @@ name = "pulley-macros"
repository = "https://github.com/bytecodealliance/wasmtime/tree/main/pulley/macros"
version.workspace = true
+[lints]
+workspace = true
+
[dependencies]
syn = { workspace = true, features = ['full'] }
quote = { workspace = true }