Fix clippy lints and formatting

Schottkyc137 · Schottkyc137 · commit be2a10f3cfa4 · 2026-02-15T09:50:46.000+01:00
diff --git a/.github/workflows/build-test-all.yml b/.github/workflows/build-test-all.yml
@@ -16,10 +16,10 @@ jobs:
     strategy:
       matrix:
         crate:
-          - vhdl_lang
-          - vhdl_ls
-          - vhdl_syntax
-          - vhdl-dump-ast
+          - { name: "vhdl_lang", path: "crates/vhdl_lang", binary: true }
+          - { name: "vhdl_ls", path: "crates/vhdl_ls", binary: true }
+          - { name: "vhdl_syntax", path: "crates/vhdl_syntax", binary: false }
+          - { name: "vhdl-dump-ast", path: "crates/vhdl-dump-ast", binary: false }
         target:
           - x86_64-unknown-linux-gnu
           - x86_64-unknown-linux-musl
@@ -51,11 +51,15 @@ jobs:
         uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ matrix.rust }}
-          target: x86_64-unknown-linux-musl
+          target: ${{ matrix.target }}
           components: rustfmt, clippy
-
-      - name: Add Apple Silicon Dependencies
-        run: rustup target add aarch64-apple-darwin
+      - name: Cache cargo
+        uses: actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: ${{ runner.os }}-${{ matrix.target }}-${{ matrix.rust }}-${{ matrix.crate.name }}-${{ hashFiles('**/Cargo.lock') }}
 
       - uses: awalsh128/cache-apt-pkgs-action@5902b33ae29014e6ca012c5d8025d4346556bd40  # v1.5.0
         if: matrix.os == 'ubuntu-latest'
@@ -64,34 +68,34 @@ jobs:
           version: 1.0
 
       - name: Build
-        run: cargo build --manifest-path ${{ matrix.crate }}/Cargo.toml --release --target ${{ matrix.target }}
+        run: cargo build --manifest-path ${{ matrix.crate.path }}/Cargo.toml --release --target ${{ matrix.target }}
 
       - name: Test
         if: matrix.os != 'macos-latest' # There are no free runners for Apple Silicon available at the moment
-        run: cargo test --manifest-path ${{ matrix.crate }}/Cargo.toml --release --target ${{ matrix.target }}
+        run: cargo test --manifest-path ${{ matrix.crate.path }}/Cargo.toml --release --target ${{ matrix.target }}
 
       - name: rustfmt
         if: matrix.os == 'ubuntu-latest' && matrix.rust == 'stable'
-        run: cargo fmt --package ${{ matrix.crate }} -- --check
+        run: cargo fmt --manifest-path ${{ matrix.crate.path }}/Cargo.toml -- --check
 
       - name: clippy
-        if: matrix.os == 'ubuntu-latest'
-        run: cargo clippy --package ${{ matrix.crate }} --all-targets --all-features -- -D warnings
+        if: ${{ matrix.os == 'ubuntu-latest' && matrix.target == 'x86_64-unknown-linux-gnu' }}
+        run: cargo clippy --manifest-path ${{ matrix.crate.path }}/Cargo.toml --all-targets --all-features -- -D warnings
 
       - name: Assemble
-        if: matrix.rust == 'stable'
+        if: ${{ matrix.crate.binary == true && matrix.rust == 'stable' }}
         run: |
-          mkdir ${{ matrix.crate }}-${{ matrix.target }}
-          mkdir ${{ matrix.crate }}-${{ matrix.target }}/bin
-          cp -R vhdl_libraries ${{ matrix.crate }}-${{ matrix.target }}
-          cp target/${{ matrix.target }}/release/${{ matrix.crate }}${{ matrix.ext }} ${{ matrix.crate }}-${{ matrix.target }}/bin
+          mkdir ${{ matrix.crate.name }}-${{ matrix.target }}
+          mkdir ${{ matrix.crate.name }}-${{ matrix.target }}/bin
+          cp -R vhdl_libraries ${{ matrix.crate.name }}-${{ matrix.target }}
+          cp target/${{ matrix.target }}/release/${{ matrix.crate.name }}${{ matrix.ext }} ${{ matrix.crate.name }}-${{ matrix.target }}/bin
 
       - name: Upload
-        if: matrix.rust == 'stable'
+        if: ${{ matrix.crate.binary == true && matrix.rust == 'stable' }}
         uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02  # v4.6.2
         with:
-          name: ${{ matrix.crate }}-${{ matrix.target }}
-          path: ${{ matrix.crate }}-${{ matrix.target }}
+          name: ${{ matrix.crate.name }}-${{ matrix.target }}
+          path: ${{ matrix.crate.name }}-${{ matrix.target }}
 
   release:
     name: Release
@@ -128,7 +132,7 @@ jobs:
           version_string=$(~/temp/vhdl_ls-x86_64-unknown-linux-musl/bin/vhdl_ls --version)
           if [ "$version_string" != "vhdl_ls $v" ]
           then
-            echo "Version string mismatch (\"$version_string\" != \"vhdl_lang $v\""
+            echo "Version string mismatch (\"$version_string\" != \"vhdl_ls $v\""
             exit 1
           else
             echo "Version string matched"
diff --git a/vhdl_syntax/examples/linting.rs b/vhdl_syntax/examples/linting.rs
@@ -11,7 +11,6 @@ use vhdl_syntax::syntax::EntityDeclarationSyntax;
 
 /// Showcases how one could write a simple linter that checks that the declared name and final name
 /// of an entity match.
-
 fn main() {
     let vhdl = "\
 entity baz is
diff --git a/vhdl_syntax/src/fmt/mod.rs b/vhdl_syntax/src/fmt/mod.rs
@@ -1,4 +1,4 @@
 //! Provides facilities to format nodes and tokens to encoded strings.
 
-pub mod utf8;
 pub mod latin1;
+pub mod utf8;
diff --git a/vhdl_syntax/src/fmt/utf8.rs b/vhdl_syntax/src/fmt/utf8.rs
@@ -1,5 +1,5 @@
 //! Provides facilities to format nodes and tokens to UTF-8 encoded strings.
-//! 
+//!
 //! # Important considerations
 //!
 //! ## Latin1 encoding
@@ -10,15 +10,15 @@
 //! the encoding is simply `[0xE9]`.
 //! As a consequence, the round-trip VHDL-file -> parse -> to string is not guaranteed to yield
 //! the same result.
-//! 
-//! If you want to format to Latin-1, consider using the [fmt::latin1](crate::fmt::latin1) module. 
+//!
+//! If you want to format to Latin-1, consider using the [fmt::latin1](crate::fmt::latin1) module.
 //!  
 //! ## Comment handling
-//! 
+//!
 //! VHDL allows comments to have a different encoding compared to the rest of the file.
 //! This implementation assumes `UTF-8` and will replace every invalid UTF-8 sequences
 //! with `U+FFFD REPLACEMENT CHARACTER`, which looks like this: �
-//! 
+//!
 //! To circumvent the issues from above, the byte-oriented facilities
 //! (e.g., [SyntaxNode::write_to], [Token::write_to]) can be used. These always guarantee that the round-trip
 //! VHDL-file -> parse -> write will yield the exact same result.
diff --git a/vhdl_syntax/src/parser/productions/concurrent_statement.rs b/vhdl_syntax/src/parser/productions/concurrent_statement.rs
@@ -193,7 +193,7 @@ impl Parser {
             _ => {
                 self.skip();
                 self.expect_tokens_err([Keyword(Kw::Block)])
-            },
+            }
         }
     }
 
diff --git a/vhdl_syntax/src/parser/productions/mod.rs b/vhdl_syntax/src/parser/productions/mod.rs
@@ -9,9 +9,9 @@ pub mod association_lists;
 pub mod attributes;
 pub mod component_declaration;
 pub mod composite_types;
-pub mod context;
 pub mod concurrent_statement;
 pub mod configuration_declarations;
+pub mod context;
 pub mod declarations;
 pub mod design;
 pub mod entity_declaration;
diff --git a/vhdl_syntax/src/parser/productions/names.rs b/vhdl_syntax/src/parser/productions/names.rs
@@ -373,9 +373,7 @@ mod tests {
 
     #[test]
     fn test_external_name_explicit_relative_multiple_levels() {
-        insta::assert_snapshot!(name_to_test_text(
-            "<< signal ^.^.^.dut.gen : std_logic >>"
-        ));
+        insta::assert_snapshot!(name_to_test_text("<< signal ^.^.^.dut.gen : std_logic >>"));
     }
 
     #[test]
diff --git a/vhdl_syntax/src/parser/util.rs b/vhdl_syntax/src/parser/util.rs
@@ -115,7 +115,10 @@ impl Parser {
         }
     }
 
-    pub(crate) fn expect_one_of_tokens<const N: usize>(&mut self, kinds: [TokenKind; N]) -> Option<TokenKind> {
+    pub(crate) fn expect_one_of_tokens<const N: usize>(
+        &mut self,
+        kinds: [TokenKind; N],
+    ) -> Option<TokenKind> {
         for kind in kinds {
             if self.opt_token(kind) {
                 return Some(kind);
@@ -126,11 +129,17 @@ impl Parser {
     }
 
     pub(crate) fn peek_token(&self) -> TokenKind {
-        self.token_stream.peek(0).map(|tok| tok.kind()).unwrap_or(TokenKind::Eof)
+        self.token_stream
+            .peek(0)
+            .map(|tok| tok.kind())
+            .unwrap_or(TokenKind::Eof)
     }
 
     pub(crate) fn peek_nth_token(&self, n: usize) -> TokenKind {
-        self.token_stream.peek(n).map(|tok| tok.kind()).unwrap_or(TokenKind::Eof)
+        self.token_stream
+            .peek(n)
+            .map(|tok| tok.kind())
+            .unwrap_or(TokenKind::Eof)
     }
 
     pub(crate) fn next_is(&self, kind: TokenKind) -> bool {
diff --git a/vhdl_syntax/src/serde/flags.rs b/vhdl_syntax/src/serde/flags.rs
@@ -10,10 +10,10 @@
 //! let flags = SerdeFlags::default()
 //!     .include_trivia(false)
 //!     .include_loc(true);
-//! 
+//!
 //! // Serialized data will not include trivia information
 //! assert!(!flags.includes_trivia());
-//! 
+//!
 //! // Serialized data will include source location
 //! assert!(flags.includes_loc());
 //! ```
@@ -31,7 +31,7 @@ impl Default for SerdeFlags {
         Self {
             include_trivia: true,
             include_loc: true,
-            comment_encoding: "utf-8".into()
+            comment_encoding: "utf-8".into(),
         }
     }
 }
@@ -61,7 +61,7 @@ impl SerdeFlags {
 
     /// Comments in VHDL can have arbitrary encoding. This flag allows serializers to specify an
     /// encoding that is attached to individual comments in the serialized AST.
-    /// 
+    ///
     /// Currently, this encoding serves merely as an information to consumers.
     /// It is not enforced nor is the string actually encoded using the specified value.
     /// This may change in the future.
diff --git a/vhdl_syntax/src/serde/mod.rs b/vhdl_syntax/src/serde/mod.rs
@@ -1,7 +1,7 @@
 //! Support for serializing and de-serializing syntax elements.
 
-pub mod serialize_impl;
 pub mod flags;
+pub mod serialize_impl;
 pub use flags::SerdeFlags;
 pub mod serializable;
 pub use serializable::Serializable;
diff --git a/vhdl_syntax/src/serde/serializable.rs b/vhdl_syntax/src/serde/serializable.rs
@@ -13,7 +13,10 @@ pub struct Serializable<'a, T> {
 
 impl<'a, T> Serializable<'a, T> {
     pub fn new(inner: &'a T, flags: impl Into<Rc<SerdeFlags>>) -> Serializable<'a, T> {
-        Serializable { inner, flags: flags.into() }
+        Serializable {
+            inner,
+            flags: flags.into(),
+        }
     }
 
     pub fn new_default(inner: &'a T) -> Serializable<'a, T> {
diff --git a/vhdl_syntax/src/serde/to_serializable.rs b/vhdl_syntax/src/serde/to_serializable.rs
@@ -1,6 +1,9 @@
 //! Provides traits for converting nodes to serializable representations.
 
-use crate::{serde::{flags::SerdeFlags, serializable::Serializable}, syntax::node::SyntaxNode};
+use crate::{
+    serde::{flags::SerdeFlags, serializable::Serializable},
+    syntax::node::SyntaxNode,
+};
 
 /// Trait for types that can be converted to a serializable view.
 pub trait ToSerializable
diff --git a/vhdl_syntax/src/syntax/node.rs b/vhdl_syntax/src/syntax/node.rs
@@ -154,7 +154,9 @@ impl SyntaxToken {
     /// trivia of this token, if there is no next token.
     /// TODO: After trivia-interning, we should be able to return `&Trivia` here, similar to `leading_trivia`
     pub fn trailing_trivia(&self) -> Trivia {
-        self.next_token().map(|tok| tok.leading_trivia().to_owned()).unwrap_or_default()
+        self.next_token()
+            .map(|tok| tok.leading_trivia().to_owned())
+            .unwrap_or_default()
     }
 
     pub fn text(&self) -> &Latin1Str {
@@ -206,20 +208,12 @@ impl SyntaxToken {
     }
 
     pub fn clone_with_text(&self, text: impl Into<Box<Latin1Str>>) -> SyntaxToken {
-        let token = Token::new(
-            self.kind(),
-            text,
-            self.green().leading_trivia().clone(),
-        );
+        let token = Token::new(self.kind(), text, self.green().leading_trivia().clone());
         self.clone_with_token(token)
     }
 
     pub fn clone_with_leading_trivia(&self, trivia: Trivia) -> SyntaxToken {
-        let token = Token::new(
-            self.kind(),
-            self.green().text(),
-            trivia,
-        );
+        let token = Token::new(self.kind(), self.green().text(), trivia);
         self.clone_with_token(token)
     }
 
@@ -638,10 +632,22 @@ mod tests {
     fn next_token() {
         let mut top = GreenNodeData::new(DesignFile);
         let mut n1 = GreenNodeData::new(EntityDeclaration);
-        n1.push_tokens(0, [Token::simple(TokenKind::Keyword(Keyword::Entity), b"entity"), Token::simple(TokenKind::Identifier, b"foo")]);
+        n1.push_tokens(
+            0,
+            [
+                Token::simple(TokenKind::Keyword(Keyword::Entity), b"entity"),
+                Token::simple(TokenKind::Identifier, b"foo"),
+            ],
+        );
         let n1 = GreenNode::new(n1);
         let mut n2 = GreenNodeData::new(ArchitectureBody);
-        n2.push_tokens(0, [Token::simple(TokenKind::Keyword(Keyword::Architecture), b"architecture"), Token::simple(TokenKind::Identifier, b"bar")]);
+        n2.push_tokens(
+            0,
+            [
+                Token::simple(TokenKind::Keyword(Keyword::Architecture), b"architecture"),
+                Token::simple(TokenKind::Identifier, b"bar"),
+            ],
+        );
         let n2 = GreenNode::new(n2);
 
         top.push_children([GreenChild::Node((0, n1)), GreenChild::Node((0, n2))]);
diff --git a/vhdl_syntax/src/tokens/token.rs b/vhdl_syntax/src/tokens/token.rs
@@ -17,11 +17,7 @@ pub struct Token {
 }
 
 impl Token {
-    pub fn new(
-        kind: TokenKind,
-        text: impl Into<Box<Latin1Str>>,
-        leading_trivia: Trivia,
-    ) -> Token {
+    pub fn new(kind: TokenKind, text: impl Into<Box<Latin1Str>>, leading_trivia: Trivia) -> Token {
         Token {
             leading_trivia,
             symbol: Symbol::allocate(kind, text.into()),
diff --git a/vhdl_syntax/src/tokens/tokenizer.rs b/vhdl_syntax/src/tokens/tokenizer.rs
diff --git a/vhdl_syntax/src/tokens/trivia_piece.rs b/vhdl_syntax/src/tokens/trivia_piece.rs

Original file line number	Diff line number	Diff line change
`@@ -193,7 +193,7 @@ impl Parser {`
`193`	`193`	`_ => {`
`194`	`194`	`self.skip();`
`195`	`195`	`self.expect_tokens_err([Keyword(Kw::Block)])`
`196`		`- },`
	`196`	`+ }`
`197`	`197`	`}`
`198`	`198`	`}`
`199`	`199`
Original file line number	Diff line number	Diff line change
`@@ -373,9 +373,7 @@ mod tests {`
`373`	`373`
`374`	`374`	`#[test]`
`375`	`375`	`fn test_external_name_explicit_relative_multiple_levels() {`
`376`		`- insta::assert_snapshot!(name_to_test_text(`
`377`		`- "<< signal ^.^.^.dut.gen : std_logic >>"`
`378`		`- ));`
	`376`	`+ insta::assert_snapshot!(name_to_test_text("<< signal ^.^.^.dut.gen : std_logic >>"));`
`379`	`377`	`}`
`380`	`378`
`381`	`379`	`#[test]`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,10 @@ impl Parser {`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`118`		`- pub(crate) fn expect_one_of_tokens<const N: usize>(&mut self, kinds: [TokenKind; N]) -> Option<TokenKind> {`
	`118`	`+ pub(crate) fn expect_one_of_tokens<const N: usize>(`
	`119`	`+ &mut self,`
	`120`	`+ kinds: [TokenKind; N],`
	`121`	`+ ) -> Option<TokenKind> {`
`119`	`122`	`for kind in kinds {`
`120`	`123`	`if self.opt_token(kind) {`
`121`	`124`	`return Some(kind);`
`@@ -126,11 +129,17 @@ impl Parser {`
`126`	`129`	`}`
`127`	`130`
`128`	`131`	`pub(crate) fn peek_token(&self) -> TokenKind {`
`129`		`- self.token_stream.peek(0).map(\|tok\| tok.kind()).unwrap_or(TokenKind::Eof)`
	`132`	`+ self.token_stream`
	`133`	`+ .peek(0)`
	`134`	`+ .map(\|tok\| tok.kind())`
	`135`	`+ .unwrap_or(TokenKind::Eof)`
`130`	`136`	`}`
`131`	`137`
`132`	`138`	`pub(crate) fn peek_nth_token(&self, n: usize) -> TokenKind {`
`133`		`- self.token_stream.peek(n).map(\|tok\| tok.kind()).unwrap_or(TokenKind::Eof)`
	`139`	`+ self.token_stream`
	`140`	`+ .peek(n)`
	`141`	`+ .map(\|tok\| tok.kind())`
	`142`	`+ .unwrap_or(TokenKind::Eof)`
`134`	`143`	`}`
`135`	`144`
`136`	`145`	`pub(crate) fn next_is(&self, kind: TokenKind) -> bool {`