From 39962ab264741b0814d512af32750f12eea9371f Mon Sep 17 00:00:00 2001 From: Marcel Hellwig Date: Wed, 12 Mar 2025 09:29:20 +0100 Subject: [PATCH 1/6] prevent possible panic due to underflowing subtraction During testing I encountered a few panics, because `12 -` was wrapping around. I think `saturating_sub` is the correct behavoir here --- crates/veryl/src/main.rs | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/crates/veryl/src/main.rs b/crates/veryl/src/main.rs index bd37ec65a..fe0f3c6da 100644 --- a/crates/veryl/src/main.rs +++ b/crates/veryl/src/main.rs @@ -52,11 +52,13 @@ fn main() -> Result { "{} {}{}", style.apply_to(format!("[{:<5}]", record.level())), " ".repeat( - 12 - format!("{message}") - .split_ascii_whitespace() - .next() - .unwrap() - .len() + 12_usize.saturating_sub( + format!("{message}") + .split_ascii_whitespace() + .next() + .unwrap() + .len() + ) ), message )) From c85f14303f3aa7f28e6cc616bf4d96969cbbeb08 Mon Sep 17 00:00:00 2001 From: Marcel Hellwig Date: Wed, 12 Mar 2025 09:32:56 +0100 Subject: [PATCH 2/6] Introduce more than one wavedump format For now, VCD (the default) and FST are supported. I did this, because fst supports nicer things, e.g. struct and enum support in the wavedump. More formats can be added later easily with this approach --- crates/metadata/src/lib.rs | 2 +- crates/metadata/src/test.rs | 20 +++++++++++++++++++ crates/veryl/src/runner.rs | 19 +++++++++++++----- crates/veryl/src/runner/vcs.rs | 20 +++++++++++-------- crates/veryl/src/runner/verilator.rs | 19 ++++++++++++------ crates/veryl/src/runner/vivado.rs | 30 +++++++++++++++++----------- 6 files changed, 78 insertions(+), 32 deletions(-) diff --git a/crates/metadata/src/lib.rs b/crates/metadata/src/lib.rs index 21baea1ea..15a462ddb 100644 --- a/crates/metadata/src/lib.rs +++ b/crates/metadata/src/lib.rs @@ -23,4 +23,4 @@ pub use project::Project; pub use pubfile::{Pubfile, Release}; pub use publish::Publish; pub use semver; -pub use test::{SimType, Test, WaveFormTarget}; +pub use test::{SimType, Test, WaveFormFormat, WaveFormTarget}; diff --git a/crates/metadata/src/test.rs b/crates/metadata/src/test.rs index 7f1c8c79d..6a6193afb 100644 --- a/crates/metadata/src/test.rs +++ b/crates/metadata/src/test.rs @@ -14,6 +14,8 @@ pub struct Test { pub vivado: VivadoProperty, #[serde(default)] pub waveform_target: WaveFormTarget, + #[serde(default)] + pub waveform_format: WaveFormFormat, } #[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, PartialEq, Eq)] @@ -65,3 +67,21 @@ pub enum WaveFormTarget { #[serde(rename = "directory")] Directory { path: PathBuf }, } + +#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, PartialEq, Eq)] +pub enum WaveFormFormat { + #[default] + #[serde(rename = "vcd")] + Vcd, + #[serde(rename = "fst")] + Fst, +} + +impl WaveFormFormat { + pub fn extension(self) -> &'static str { + match self { + WaveFormFormat::Vcd => "vcd", + WaveFormFormat::Fst => "fst", + } + } +} diff --git a/crates/veryl/src/runner.rs b/crates/veryl/src/runner.rs index b847dd41c..63a05b7bf 100644 --- a/crates/veryl/src/runner.rs +++ b/crates/veryl/src/runner.rs @@ -106,13 +106,22 @@ pub fn copy_wave( metadata: &Metadata, work_path: &Path, ) -> Result<()> { + // The file always has a `.vcd` extension, because `$dumpfile` doesn't have the metadata information let wave_src_path = work_path.join(format!("{}.vcd", test_name)); + + // but let's rename the target file to the correct extension, based on the selected format + let target_name = format!( + "{}.{}", + test_name, + metadata.test.waveform_format.extension() + ); + let wave_dst_path = match &metadata.test.waveform_target { - WaveFormTarget::Target => { - let target = PathBuf::from(test_path.to_string()); - target.parent().unwrap().join(format!("{}.vcd", test_name)) - } - WaveFormTarget::Directory { path } => path.join(format!("{}.vcd", test_name)), + WaveFormTarget::Target => PathBuf::from(test_path.to_string()) + .parent() + .unwrap() + .join(target_name), + WaveFormTarget::Directory { path } => path.join(target_name), }; let wave_dst_dir = wave_dst_path.parent().unwrap(); diff --git a/crates/veryl/src/runner/vcs.rs b/crates/veryl/src/runner/vcs.rs index f2b7c768e..7c6abbad3 100644 --- a/crates/veryl/src/runner/vcs.rs +++ b/crates/veryl/src/runner/vcs.rs @@ -1,6 +1,6 @@ use crate::runner::{Runner, copy_wave, remap_msg_by_regex}; use futures::prelude::*; -use log::{error, info}; +use log::{error, info, warn}; use miette::{IntoDiagnostic, Result, WrapErr}; use once_cell::sync::Lazy; use regex::Regex; @@ -8,7 +8,7 @@ use std::process::Stdio; use tokio::process::{Child, Command}; use tokio::runtime::Runtime; use tokio_util::codec::{FramedRead, LinesCodec}; -use veryl_metadata::Metadata; +use veryl_metadata::{Metadata, WaveFormFormat}; use veryl_parser::resource_table::{PathId, StrId}; #[derive(Copy, Clone, Debug, PartialEq, Eq)] @@ -124,7 +124,7 @@ impl Runner for Vcs { test: StrId, _top: Option, path: PathId, - wave: bool, + mut wave: bool, ) -> Result { self.success = true; @@ -136,12 +136,16 @@ impl Runner for Vcs { "+define+__veryl_test_{}_{}__", metadata.project.name, test )]; - if wave { - defines.push(format!( - "+define+__veryl_wavedump_{}_{}__", - metadata.project.name, test - )); + if WaveFormFormat::Vcd == metadata.test.waveform_format { + defines.push(format!( + "+define+__veryl_wavedump_{}_{}__", + metadata.project.name, test + )); + } else { + warn!("Only VCD is supported as a waveform format for vcs!"); + wave = false; + } } let rt = Runtime::new().unwrap(); diff --git a/crates/veryl/src/runner/verilator.rs b/crates/veryl/src/runner/verilator.rs index bb4932aee..ae88363d4 100644 --- a/crates/veryl/src/runner/verilator.rs +++ b/crates/veryl/src/runner/verilator.rs @@ -8,7 +8,7 @@ use std::process::Stdio; use tokio::process::{Child, Command}; use tokio::runtime::Runtime; use tokio_util::codec::{FramedRead, LinesCodec}; -use veryl_metadata::Metadata; +use veryl_metadata::{Metadata, WaveFormFormat}; use veryl_parser::resource_table::{PathId, StrId}; #[derive(Copy, Clone, Debug, PartialEq, Eq)] @@ -147,17 +147,24 @@ impl Runner for Verilator { metadata.project.name, test )]; + let mut opt = vec!["--assert", "--binary", "-Wno-MULTITOP"]; + if wave { defines.push(format!( "+define+__veryl_wavedump_{}_{}__", metadata.project.name, test )); - } - let mut opt = vec!["--assert", "--binary", "-Wno-MULTITOP"]; - - if wave { - opt.push("--trace"); + match metadata.test.waveform_format { + WaveFormFormat::Vcd => opt.push("--trace"), + WaveFormFormat::Fst => opt.extend(&[ + "--trace-fst", + "--trace-threads", + "2", + "--trace-structs", + "--trace-params", + ]), + } } let rt = Runtime::new().unwrap(); diff --git a/crates/veryl/src/runner/vivado.rs b/crates/veryl/src/runner/vivado.rs index 17f409f00..d0d867110 100644 --- a/crates/veryl/src/runner/vivado.rs +++ b/crates/veryl/src/runner/vivado.rs @@ -1,6 +1,6 @@ use crate::runner::{Runner, copy_wave, remap_msg_by_regex}; use futures::prelude::*; -use log::{error, info}; +use log::{error, info, warn}; use miette::{IntoDiagnostic, Result, WrapErr}; use once_cell::sync::Lazy; use regex::Regex; @@ -8,7 +8,7 @@ use std::process::Stdio; use tokio::process::{Child, Command}; use tokio::runtime::Runtime; use tokio_util::codec::{FramedRead, LinesCodec}; -use veryl_metadata::Metadata; +use veryl_metadata::{Metadata, WaveFormFormat}; use veryl_parser::resource_table::{PathId, StrId}; #[derive(Copy, Clone, Debug, PartialEq, Eq)] @@ -107,7 +107,7 @@ impl Runner for Vivado { test: StrId, _top: Option, path: PathId, - wave: bool, + mut wave: bool, ) -> Result { self.success = true; @@ -121,11 +121,16 @@ impl Runner for Vivado { ]; if wave { - defines.push("-d".to_string()); - defines.push(format!( - "__veryl_wavedump_{}_{}__", - metadata.project.name, test - )); + if WaveFormFormat::Vcd == metadata.test.waveform_format { + defines.push("-d".to_string()); + defines.push(format!( + "__veryl_wavedump_{}_{}__", + metadata.project.name, test + )); + } else { + warn!("Only VCD is supported as a waveform format for vivado!"); + wave = false; + } } let rt = Runtime::new().unwrap(); @@ -154,12 +159,13 @@ impl Runner for Vivado { info!("Elaborating test ({})", test); - let opt = if wave { vec!["-debug", "all"] } else { vec![] }; - let mut top = vec![test.to_string()]; - if wave { + let opt = if wave && WaveFormFormat::Vcd == metadata.test.waveform_format { top.push("__veryl_wavedump".to_string()); - } + vec!["-debug", "all"] + } else { + vec![] + }; rt.block_on(async { let elaborate = Command::new("xelab") From a4597e48a1d09eb29d9a77ec8dd5062edf864e25 Mon Sep 17 00:00:00 2001 From: Marcel Hellwig Date: Wed, 12 Mar 2025 11:45:26 +0100 Subject: [PATCH 3/6] implement waveform generation for cocotb/verilator --- crates/veryl/src/runner/cocotb.rs | 31 ++++++++++++++++++++++++++++--- 1 file changed, 28 insertions(+), 3 deletions(-) diff --git a/crates/veryl/src/runner/cocotb.rs b/crates/veryl/src/runner/cocotb.rs index b9fc42dfe..57ac10f56 100644 --- a/crates/veryl/src/runner/cocotb.rs +++ b/crates/veryl/src/runner/cocotb.rs @@ -1,4 +1,4 @@ -use crate::runner::Runner; +use crate::runner::{Runner, copy_wave}; use futures::prelude::*; use log::{error, info}; use miette::{IntoDiagnostic, Result, WrapErr}; @@ -8,7 +8,7 @@ use std::process::Stdio; use tokio::process::{Child, Command}; use tokio::runtime::Runtime; use tokio_util::codec::{FramedRead, LinesCodec}; -use veryl_metadata::Metadata; +use veryl_metadata::{Metadata, WaveFormFormat}; use veryl_parser::resource_table::{self, PathId, StrId}; #[derive(Copy, Clone, Debug, PartialEq, Eq)] @@ -119,7 +119,7 @@ impl Runner for Cocotb { test: StrId, top: Option, path: PathId, - _wave: bool, + wave: bool, ) -> Result { self.success = true; @@ -163,6 +163,14 @@ impl Runner for Cocotb { let module = format!("{}_{}", metadata.project.name, top.unwrap()); + let (py_waves, args) = match wave.then_some(metadata.test.waveform_format) { + Some(WaveFormFormat::Vcd) => ("True", "['--trace']"), + Some(WaveFormFormat::Fst) => ( + "True", + "['--trace-fst', '--trace-structs', '--trace-threads', '2']", + ), + None => ("False", ""), + }; let runner_path = temp_dir.path().join("runner.py"); let runner_text = format!( r#" @@ -176,11 +184,14 @@ runner.build( verilog_sources=sources, hdl_toplevel="{module}", always=True, + waves={py_waves}, + build_args={args}, ) runner.test( hdl_toplevel="{module}", test_module="{test},", + waves={py_waves}, ) "# ); @@ -209,6 +220,20 @@ runner.test( self.parse(compile).await })?; + if wave { + // `copy_wave` expects the waveform at a certain position and format + fs::copy( + temp_dir + .path() + .join("sim_build") + .join("dump") + .with_extension(metadata.test.waveform_format.extension()), + temp_dir.path().join(test.to_string()).with_extension("vcd"), + ) + .into_diagnostic()?; + copy_wave(test, path, metadata, temp_dir.path())?; + } + if self.success { info!("Succeeded test ({})", test); Ok(true) From b0846f7d64b1211e7590107a148aece9e07deb90 Mon Sep 17 00:00:00 2001 From: Marcel Hellwig Date: Thu, 13 Mar 2025 11:25:59 +0100 Subject: [PATCH 4/6] Reduce size of error path drasticly warning: the `Err`-variant returned from this function is very large --> crates/analyzer/src/symbol_table.rs:1277:58 | 1277 | pub fn resolve>(path: T) -> Result { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 736 bytes | = help: try reducing the size of `symbol_table::ResolveError`, for example by boxing large elements or replacing it with `Box` = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#result_large_err By introducing a box, we now went down from 736 to 24 bytes! warning: the `Err`-variant returned from this function is very large --> crates/analyzer/src/type_dag.rs:225:56 | 47 | Cyclic(Symbol, Symbol), | ---------------------- the largest variant contains at least 1440 bytes ... 225 | pub fn insert_node(symbol_id: SymbolId, name: &str) -> Result { | ^^^^^^^^^^^^^^^^^^^^^ | = help: try reducing the size of `type_dag::DagError`, for example by boxing large elements or replacing it with `Box` = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#result_large_err Same here, but twice the amount (since `DagError` contains 2 symbols) --- crates/analyzer/src/symbol_table.rs | 4 ++-- crates/analyzer/src/type_dag.rs | 31 ++++++++++++++--------------- 2 files changed, 17 insertions(+), 18 deletions(-) diff --git a/crates/analyzer/src/symbol_table.rs b/crates/analyzer/src/symbol_table.rs index 493058afe..1ccb48175 100644 --- a/crates/analyzer/src/symbol_table.rs +++ b/crates/analyzer/src/symbol_table.rs @@ -20,7 +20,7 @@ pub struct ResolveResult { #[derive(Clone, Debug)] pub struct ResolveError { - pub last_found: Option, + pub last_found: Option>, pub cause: ResolveErrorCause, } @@ -34,7 +34,7 @@ pub enum ResolveErrorCause { impl ResolveError { pub fn new(last_found: Option<&Symbol>, cause: ResolveErrorCause) -> Self { Self { - last_found: last_found.cloned(), + last_found: last_found.map(|s| Box::new(s.clone())), cause, } } diff --git a/crates/analyzer/src/type_dag.rs b/crates/analyzer/src/type_dag.rs index 90e260bf2..e4efedc70 100644 --- a/crates/analyzer/src/type_dag.rs +++ b/crates/analyzer/src/type_dag.rs @@ -44,7 +44,7 @@ pub enum Context { #[derive(Debug, Clone)] pub enum DagError { - Cyclic(Symbol, Symbol), + Cyclic(Box, Box), } impl TypeDag { @@ -80,13 +80,11 @@ impl TypeDag { } } - fn get_symbol(&self, node: u32) -> Symbol { - match self.symbols.get(&node) { - Some(x) => x.clone(), - None => { - panic!("Must insert node before accessing"); - } - } + fn get_cloned_symbol(&self, node: u32) -> Symbol { + self.symbols + .get(&node) + .expect("Must insert node before accessing") + .clone() } fn insert_edge(&mut self, start: u32, end: u32, edge: Context) -> Result<(), DagError> { @@ -98,9 +96,12 @@ impl TypeDag { if matches!(edge, Context::Module | Context::Interface) && is_direct_recursion { Ok(()) } else { - let ssym = self.get_symbol(start); - let esym = self.get_symbol(end); - Err(DagError::Cyclic(ssym, esym)) + let ssym = self.get_cloned_symbol(start); + let esym = self.get_cloned_symbol(end); + Err(DagError::Cyclic( + Box::new(ssym), + Box::new(esym), + )) } } } @@ -122,8 +123,7 @@ impl TypeDag { for node in nodes { let index = node.index() as u32; if self.paths.contains_key(&index) { - let sym = self.get_symbol(index); - ret.push(sym); + ret.push(self.get_cloned_symbol(index)); } } ret @@ -142,8 +142,7 @@ impl TypeDag { while let Some(x) = dfs.next(&graph) { let index = x.index() as u32; if self.paths.contains_key(&index) { - let symbol = self.get_symbol(index); - connected.push(symbol); + connected.push(self.get_cloned_symbol(index)); } } if !connected.is_empty() { @@ -227,7 +226,7 @@ pub fn insert_node(symbol_id: SymbolId, name: &str) -> Result { } pub fn get_symbol(node: u32) -> Symbol { - TYPE_DAG.with(|f| f.borrow().get_symbol(node)) + TYPE_DAG.with(|f| f.borrow().get_cloned_symbol(node)) } pub fn toposort() -> Vec { From 8e4105e656b2a742487dfbdeb41eda8531d6762b Mon Sep 17 00:00:00 2001 From: Marcel Hellwig Date: Thu, 13 Mar 2025 11:40:47 +0100 Subject: [PATCH 5/6] using `contains()` instead of `iter().any()` is more efficient --- crates/analyzer/src/instance_history.rs | 4 +--- crates/analyzer/src/type_dag.rs | 5 +---- crates/emitter/src/emitter.rs | 7 +++---- 3 files changed, 5 insertions(+), 11 deletions(-) diff --git a/crates/analyzer/src/instance_history.rs b/crates/analyzer/src/instance_history.rs index d201ca83e..c81d2cb5e 100644 --- a/crates/analyzer/src/instance_history.rs +++ b/crates/analyzer/src/instance_history.rs @@ -52,9 +52,7 @@ impl InstanceHistory { if self.full.len() > self.total_limit { return Err(InstanceHistoryError::ExceedTotalLimit); } - if self.hierarchy.iter().any(|x| *x == sig) - && sig.params.iter().all(|x| x.1.get_value().is_some()) - { + if self.hierarchy.contains(&sig) && sig.params.iter().all(|x| x.1.get_value().is_some()) { return Err(InstanceHistoryError::InfiniteRecursion); } if self.full.contains(&sig) { diff --git a/crates/analyzer/src/type_dag.rs b/crates/analyzer/src/type_dag.rs index e4efedc70..2297f59e4 100644 --- a/crates/analyzer/src/type_dag.rs +++ b/crates/analyzer/src/type_dag.rs @@ -98,10 +98,7 @@ impl TypeDag { } else { let ssym = self.get_cloned_symbol(start); let esym = self.get_cloned_symbol(end); - Err(DagError::Cyclic( - Box::new(ssym), - Box::new(esym), - )) + Err(DagError::Cyclic(Box::new(ssym), Box::new(esym))) } } } diff --git a/crates/emitter/src/emitter.rs b/crates/emitter/src/emitter.rs index a2c9878eb..efba17cf0 100644 --- a/crates/emitter/src/emitter.rs +++ b/crates/emitter/src/emitter.rs @@ -4264,8 +4264,8 @@ pub fn symbol_string(token: &VerylToken, symbol: &Symbol, context: &SymbolContex | SymbolKind::Union(_) | SymbolKind::TypeDef(_) | SymbolKind::Enum(_) => { - let visible = namespace.included(&symbol.namespace) - || symbol.imported.iter().any(|x| *x == namespace); + let visible = + namespace.included(&symbol.namespace) || symbol.imported.contains(&namespace); if visible & !context.in_import { ret.push_str(&token_text); } else { @@ -4295,8 +4295,7 @@ pub fn symbol_string(token: &VerylToken, symbol: &Symbol, context: &SymbolContex } SymbolKind::GenericInstance(x) => { let base = symbol_table::get(x.base).unwrap(); - let visible = namespace.included(&base.namespace) - || base.imported.iter().any(|x| *x == namespace); + let visible = namespace.included(&base.namespace) || base.imported.contains(&namespace); let top_level = matches!( base.kind, SymbolKind::Module(_) | SymbolKind::Interface(_) | SymbolKind::Package(_) From cf1f630fd3804c2e9a7f3884b7f29fc1ce5bf09b Mon Sep 17 00:00:00 2001 From: Marcel Hellwig Date: Thu, 13 Mar 2025 12:05:31 +0100 Subject: [PATCH 6/6] replace once_cell::Lazy with std::sync::LazyLock --- Cargo.lock | 3 --- Cargo.toml | 1 - crates/metadata/Cargo.toml | 1 - crates/metadata/src/metadata.rs | 6 +++--- crates/parser/Cargo.toml | 1 - crates/parser/src/generated/veryl_parser.rs | 4 ++-- crates/parser/src/veryl_token.rs | 6 +++--- crates/veryl/Cargo.toml | 1 - crates/veryl/src/runner.rs | 18 +++++++++--------- crates/veryl/src/runner/vcs.rs | 6 +++--- crates/veryl/src/runner/verilator.rs | 6 +++--- crates/veryl/src/runner/vivado.rs | 4 ++-- 12 files changed, 25 insertions(+), 32 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 79cb815d7..dde188f2f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5164,7 +5164,6 @@ dependencies = [ "log", "mdbook", "miette", - "once_cell", "pulldown-cmark 0.12.2", "regex", "serde", @@ -5259,7 +5258,6 @@ dependencies = [ "git-repository", "log", "miette", - "once_cell", "regex", "semver 1.0.26", "serde", @@ -5282,7 +5280,6 @@ dependencies = [ "anyhow", "bimap", "miette", - "once_cell", "parol", "parol_runtime", "paste", diff --git a/Cargo.toml b/Cargo.toml index ec6212479..e4d9425d4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -38,7 +38,6 @@ fxhash = "0.2.1" log = "0.4.26" mdbook = "0.4.47" miette = {version = "7.5"} -once_cell = "1.21" pulldown-cmark = "0.12.2" regex = "1.11.1" semver = {version = "1.0", features = ["serde"]} diff --git a/crates/metadata/Cargo.toml b/crates/metadata/Cargo.toml index a5dfaf7dd..99192fcc0 100644 --- a/crates/metadata/Cargo.toml +++ b/crates/metadata/Cargo.toml @@ -15,7 +15,6 @@ edition.workspace = true [dependencies] git-repository = {version = "0.35.0", optional = true, features = ["blocking-network-client", "blocking-http-transport-reqwest", "blocking-http-transport-reqwest-rust-tls"]} log = {workspace = true} -once_cell = {workspace = true} regex = {workspace = true} semver = {workspace = true} serde = {workspace = true} diff --git a/crates/metadata/src/metadata.rs b/crates/metadata/src/metadata.rs index 214c49507..60d283959 100644 --- a/crates/metadata/src/metadata.rs +++ b/crates/metadata/src/metadata.rs @@ -10,7 +10,6 @@ use crate::publish::Publish; use crate::test::Test; use crate::{FilelistType, MetadataError, SourceMapTarget}; use log::{debug, info}; -use once_cell::sync::Lazy; use regex::Regex; use semver::VersionReq; use serde::{Deserialize, Serialize}; @@ -21,6 +20,7 @@ use std::fmt; use std::fs; use std::path::{Path, PathBuf}; use std::str::FromStr; +use std::sync::LazyLock; use url::Url; use veryl_path::PathSet; @@ -80,8 +80,8 @@ impl fmt::Display for UrlPath { } } -static VALID_PROJECT_NAME: Lazy = - Lazy::new(|| Regex::new(r"^[a-zA-Z_][0-9a-zA-Z_]*$").unwrap()); +static VALID_PROJECT_NAME: LazyLock = + LazyLock::new(|| Regex::new(r"^[a-zA-Z_][0-9a-zA-Z_]*$").unwrap()); impl Metadata { pub fn search_from_current() -> Result { diff --git a/crates/parser/Cargo.toml b/crates/parser/Cargo.toml index 5f756be03..32c4e123f 100644 --- a/crates/parser/Cargo.toml +++ b/crates/parser/Cargo.toml @@ -16,7 +16,6 @@ exclude = ["build.rs"] [dependencies] anyhow = {workspace = true} bimap = "0.6.3" -once_cell = {workspace = true} parol_runtime = {version = "3.0", features = ["regex_automata"], default-features = false} paste = "1.0" regex = {workspace = true} diff --git a/crates/parser/src/generated/veryl_parser.rs b/crates/parser/src/generated/veryl_parser.rs index 302984a43..febf75203 100644 --- a/crates/parser/src/generated/veryl_parser.rs +++ b/crates/parser/src/generated/veryl_parser.rs @@ -4,12 +4,12 @@ // lost after next build. // --------------------------------------------------------- -use parol_runtime::once_cell::sync::Lazy; #[allow(unused_imports)] use parol_runtime::parser::{LLKParser, LookaheadDFA, ParseTreeType, ParseType, Production, Trans}; use parol_runtime::{ParolError, ParseTree, TerminalIndex}; use parol_runtime::{ScannerConfig, TokenStream, Tokenizer}; use std::path::Path; +use std::sync::LazyLock; use crate::veryl_grammar::VerylGrammar; use crate::veryl_grammar_trait::VerylGrammarAuto; @@ -27553,7 +27553,7 @@ pub const PRODUCTIONS: &[Production; 1010] = &[ }, ]; -static SCANNERS: Lazy> = Lazy::new(|| { +static SCANNERS: LazyLock> = LazyLock::new(|| { vec![ ScannerConfig::new( "INITIAL", diff --git a/crates/parser/src/veryl_token.rs b/crates/parser/src/veryl_token.rs index 8350205d3..aad1cc3a3 100644 --- a/crates/parser/src/veryl_token.rs +++ b/crates/parser/src/veryl_token.rs @@ -2,10 +2,10 @@ use crate::doc_comment_table; use crate::resource_table::{self, PathId, StrId, TokenId}; use crate::text_table::{self, TextId}; use crate::veryl_grammar_trait::*; -use once_cell::sync::Lazy; use paste::paste; use regex::Regex; use std::fmt; +use std::sync::LazyLock; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub enum TokenSource { @@ -875,8 +875,8 @@ impl ExpressionIdentifier { } } -static COMMENT_REGEX: Lazy = - Lazy::new(|| Regex::new(r"((?://.*(?:\r\n|\r|\n|$))|(?:(?ms)/\u{2a}.*?\u{2a}/))").unwrap()); +static COMMENT_REGEX: LazyLock = + LazyLock::new(|| Regex::new(r"((?://.*(?:\r\n|\r|\n|$))|(?:(?ms)/\u{2a}.*?\u{2a}/))").unwrap()); fn split_comment_token(token: Token) -> Vec { let mut line = token.line; diff --git a/crates/veryl/Cargo.toml b/crates/veryl/Cargo.toml index dd6347773..cf4f19fe6 100644 --- a/crates/veryl/Cargo.toml +++ b/crates/veryl/Cargo.toml @@ -29,7 +29,6 @@ fern = "0.7.0" futures = {workspace = true} handlebars = "6.3" log = {workspace = true} -once_cell = {workspace = true} mdbook = {workspace = true} miette = {workspace = true} pulldown-cmark = {workspace = true} diff --git a/crates/veryl/src/runner.rs b/crates/veryl/src/runner.rs index 63a05b7bf..5cb72f23e 100644 --- a/crates/veryl/src/runner.rs +++ b/crates/veryl/src/runner.rs @@ -1,10 +1,10 @@ use anstyle::{AnsiColor, Style}; use log::{Level, debug, log_enabled}; use miette::{IntoDiagnostic, Result}; -use once_cell::sync::Lazy; use regex::Regex; use std::fs; use std::path::{Path, PathBuf}; +use std::sync::LazyLock; use veryl_metadata::{Metadata, WaveFormTarget}; use veryl_parser::resource_table::{PathId, StrId}; use veryl_sourcemap::SourceMap; @@ -39,24 +39,24 @@ pub trait Runner { } fn info(&self, line: &str) { - static STYLE: Lazy