Merge pull request #223 from jsturtevant/bump-rust-version

lifupan · web-flow · commit 44b31f733377 · 2024-04-07T17:20:03.000+08:00
Bump rust version to resolve builds
diff --git a/.github/workflows/bvt.yml b/.github/workflows/bvt.yml
@@ -12,10 +12,7 @@ jobs:
         uses: actions/checkout@v3
       - name: Check
         run: |
-          make deps
-          make check
-          make -C compiler check
-          make -C ttrpc-codegen check
+          make check-all
 
   make:
     name: Build
@@ -28,7 +25,6 @@ jobs:
         uses: actions/checkout@v3
       - name: Build
         run: |
-          make deps
           make
           make -C compiler
           make -C ttrpc-codegen
diff --git a/Cargo.toml b/Cargo.toml
@@ -9,6 +9,7 @@ readme = "README.md"
 repository = "https://github.com/containerd/ttrpc-rust"
 homepage = "https://github.com/containerd/ttrpc-rust"
 description = "A Rust version of ttrpc."
+rust-version = "1.70"
 
 [dependencies]
 protobuf = { version = "3.1.0" }
diff --git a/Makefile b/Makefile
@@ -1,5 +1,3 @@
-RUST_VERSION = 1.66
-
 all: debug test
 
 #
@@ -35,8 +33,8 @@ check:
 	cargo fmt --all -- --check
 	cargo clippy --all-targets --all-features -- -D warnings
 
-.PHONY: deps
-deps:
-	rustup install $(RUST_VERSION)
-	rustup default $(RUST_VERSION)
-	rustup component add rustfmt clippy
+.PHONY: check-all
+check-all:
+	$(MAKE) check
+	$(MAKE) -C compiler check
+	$(MAKE) -C ttrpc-codegen check
diff --git a/compiler/src/util.rs b/compiler/src/util.rs
@@ -48,7 +48,7 @@ impl<'a> Iterator for NameSpliter<'a> {
         let mut meet_lower = false;
         for i in self.pos..self.name.len() {
             let c = self.name[i];
-            if (b'A'..=b'Z').contains(&c) {
+            if c.is_ascii_uppercase() {
                 if meet_lower {
                     // So it should be AaA or aaA
                     pos = i;
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
@@ -0,0 +1,4 @@
+[toolchain]
+channel="1.77.0"
+profile="default"
+components=["rustfmt", "clippy"]
diff --git a/src/asynchronous/shutdown.rs b/src/asynchronous/shutdown.rs
@@ -305,7 +305,7 @@ mod test {
         });
         notifier.shutdown();
         // Elapsed
-        assert!(matches!(notifier.wait_all_exit().await, Err(_)));
+        assert!(notifier.wait_all_exit().await.is_err());
         task.await.unwrap();
     }
 }
diff --git a/src/sync/sys/windows/net.rs b/src/sync/sys/windows/net.rs
@@ -112,7 +112,7 @@ impl PipeListener {
                 let res = unsafe {GetOverlappedResult(np.named_pipe, ol.as_mut_ptr(), &mut bytes_transfered, WAIT_FOR_EVENT) };
                 match res {
                     0 => {
-                        return Err(io::Error::last_os_error());
+                        Err(io::Error::last_os_error())
                     }
                     _ => {
                         if let Some(shutdown_signal) = self.handle_shutdown(&np) {
@@ -129,10 +129,10 @@ impl PipeListener {
                 Ok(Some(np))
             }
             e => {
-                return Err(io::Error::new(
+                Err(io::Error::new(
                     io::ErrorKind::Other,
                     format!("failed to connect pipe: {:?}", e),
-                ));
+                ))
             }
         }
     }
@@ -165,12 +165,12 @@ impl PipeListener {
         // https://learn.microsoft.com/en-us/windows/win32/ipc/named-pipe-security-and-access-rights
         match  unsafe { CreateNamedPipeW(name.as_ptr(), open_mode, PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS, PIPE_UNLIMITED_INSTANCES, PIPE_BUFFER_SIZE, PIPE_BUFFER_SIZE, 0, std::ptr::null_mut())} {
             INVALID_HANDLE_VALUE => {
-                return Err(io::Error::last_os_error())
+                Err(io::Error::last_os_error())
             }
             h => {
-                return Ok(h)
+                Ok(h)
             },
-        };
+        }
     }
 
     pub fn close(&self) -> Result<()> {
@@ -208,8 +208,8 @@ impl PipeConnection {
         let write_event = create_event()?;
         Ok(PipeConnection {
             named_pipe: h,
-            read_event: read_event,
-            write_event: write_event,
+            read_event,
+            write_event,
         })
     }
 
@@ -236,15 +236,15 @@ impl PipeConnection {
                 let res = unsafe {GetOverlappedResult(self.named_pipe, ol.as_mut_ptr(), &mut bytes_transfered, WAIT_FOR_EVENT) };
                 match res {
                     0 => {
-                        return Err(handle_windows_error(io::Error::last_os_error()))
+                        Err(handle_windows_error(io::Error::last_os_error()))
                     }
                     _ => {
-                        return Ok(bytes_transfered as usize)
+                        Ok(bytes_transfered as usize)
                     }
                 }
             }
             ref e => {
-                return Err(Error::Others(format!("failed to read from pipe: {:?}", e)))
+                Err(Error::Others(format!("failed to read from pipe: {:?}", e)))
             }
         }
     }
@@ -267,15 +267,15 @@ impl PipeConnection {
                 let res = unsafe {GetOverlappedResult(self.named_pipe, ol.as_mut_ptr(), &mut bytes_transfered, WAIT_FOR_EVENT) };
                 match res {
                     0 => {
-                        return Err(handle_windows_error(io::Error::last_os_error()))
+                        Err(handle_windows_error(io::Error::last_os_error()))
                     }
                     _ => {
-                        return Ok(bytes_transfered as usize)
+                        Ok(bytes_transfered as usize)
                     }
                 }
             }
             ref e => {
-                return Err(Error::Others(format!("failed to write to pipe: {:?}", e)))
+                Err(Error::Others(format!("failed to write to pipe: {:?}", e)))
             }
         }
     }
@@ -346,10 +346,10 @@ impl ClientConnection {
             .custom_flags(FILE_FLAG_OVERLAPPED);
         match opts.open(self.address.as_str()) {
             Ok(file) => {
-                return PipeConnection::new(file.into_raw_handle() as isize)
+                PipeConnection::new(file.into_raw_handle() as isize)
             }
             Err(e) => {
-                return Err(handle_windows_error(e))
+                Err(handle_windows_error(e))
             }
         }
     }
@@ -383,7 +383,7 @@ mod test {
         let client = ClientConnection::new("non_existent_pipe");
         match client.get_pipe_connection() {
             Ok(_) => {
-                assert!(false, "should not be able to get a connection to a non existent pipe");
+                panic!("should not be able to get a connection to a non existent pipe");
             }
             Err(e) => {
                 assert_eq!(e, Error::Windows(ERROR_FILE_NOT_FOUND as i32));
@@ -404,10 +404,10 @@ mod test {
                     // pipe is working
                 }
                 Ok(None) => {
-                    assert!(false, "should get a working pipe")
+                    panic!("should get a working pipe")
                 }
                 Err(e) => {
-                    assert!(false, "should not get error {}", e.to_string())
+                    panic!("should not get error {}", e)
                 }
             }
         });
@@ -425,7 +425,7 @@ mod test {
             let quit_flag = Arc::new(AtomicBool::new(false));
             match listener_server.accept(&quit_flag) {
                 Ok(_) => {
-                    assert!(false, "should not get pipe on close")
+                    panic!("should not get pipe on close")
                 }
                 Err(e) => {
                     assert_eq!(e.to_string(), "closing pipe")
diff --git a/ttrpc-codegen/src/lib.rs b/ttrpc-codegen/src/lib.rs
@@ -1,3 +1,4 @@
+#![allow(dead_code)]
 //! API to generate .rs files for ttrpc from protobuf
 //!
 //!
diff --git a/ttrpc-codegen/src/model.rs b/ttrpc-codegen/src/model.rs
@@ -8,20 +8,15 @@ use crate::str_lit::StrLit;
 use protobuf_support::lexer::float;
 
 /// Protobox syntax
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
 pub enum Syntax {
     /// Protobuf syntax [2](https://developers.google.com/protocol-buffers/docs/proto) (default)
+    #[default]
     Proto2,
     /// Protobuf syntax [3](https://developers.google.com/protocol-buffers/docs/proto3)
     Proto3,
 }
 
-impl Default for Syntax {
-    fn default() -> Syntax {
-        Syntax::Proto2
-    }
-}
-
 /// A field rule
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 pub enum Rule {
diff --git a/ttrpc-codegen/src/parser.rs b/ttrpc-codegen/src/parser.rs
@@ -387,11 +387,11 @@ impl<'a> Lexer<'a> {
 
     // capitalLetter =  "A" … "Z"
     fn _next_capital_letter_opt(&mut self) -> Option<char> {
-        self.next_char_if(|c| ('A'..='Z').contains(&c))
+        self.next_char_if(|c| c.is_ascii_uppercase())
     }
 
     fn is_ascii_alphanumeric(c: char) -> bool {
-        ('a'..='z').contains(&c) || ('A'..='Z').contains(&c) || ('0'..='9').contains(&c)
+        c.is_ascii_lowercase() || c.is_ascii_uppercase() || c.is_ascii_digit()
     }
 
     fn next_ident_part(&mut self) -> Option<char> {
@@ -417,7 +417,7 @@ impl<'a> Lexer<'a> {
     // Integer literals
 
     fn is_ascii_hexdigit(c: char) -> bool {
-        ('0'..='9').contains(&c) || ('a'..='f').contains(&c) || ('A'..='F').contains(&c)
+        c.is_ascii_digit() || ('a'..='f').contains(&c) || ('A'..='F').contains(&c)
     }
 
     // hexLit     = "0" ( "x" | "X" ) hexDigit { hexDigit }
@@ -433,7 +433,7 @@ impl<'a> Lexer<'a> {
     }
 
     fn is_ascii_digit(c: char) -> bool {
-        ('0'..='9').contains(&c)
+        c.is_ascii_digit()
     }
 
     // decimalLit = ( "1" … "9" ) { decimalDigit }
@@ -458,7 +458,7 @@ impl<'a> Lexer<'a> {
     fn next_hex_digit(&mut self) -> ParserResult<u32> {
         let mut clone = *self;
         let r = match clone.next_char()? {
-            c if ('0'..='9').contains(&c) => c as u32 - b'0' as u32,
+            c if c.is_ascii_digit() => c as u32 - b'0' as u32,
             c if ('A'..='F').contains(&c) => c as u32 - b'A' as u32 + 10,
             c if ('a'..='f').contains(&c) => c as u32 - b'a' as u32 + 10,
             _ => return Err(ParserError::ExpectHexDigit),
@@ -482,7 +482,7 @@ impl<'a> Lexer<'a> {
     fn next_decimal_digit(&mut self) -> ParserResult<u32> {
         let mut clone = *self;
         let r = match clone.next_char()? {
-            c if ('0'..='9').contains(&c) => c as u32 - '0' as u32,
+            c if c.is_ascii_digit() => c as u32 - '0' as u32,
             _ => return Err(ParserError::ExpectDecDigit),
         };
         *self = clone;
@@ -492,7 +492,7 @@ impl<'a> Lexer<'a> {
     // decimals  = decimalDigit { decimalDigit }
     fn next_decimal_digits(&mut self) -> ParserResult<()> {
         self.next_decimal_digit()?;
-        self.take_while(|c| ('0'..='9').contains(&c));
+        self.take_while(|c| c.is_ascii_digit());
         Ok(())
     }
 
@@ -1029,7 +1029,7 @@ impl<'a> Parser<'a> {
     }
 
     fn is_ascii_uppercase(c: char) -> bool {
-        ('A'..='Z').contains(&c)
+        c.is_ascii_uppercase()
     }
 
     // groupName = capitalLetter { letter | decimalDigit | "_" }

Original file line number	Diff line number	Diff line change
`@@ -305,7 +305,7 @@ mod test {`
`305`	`305`	`});`
`306`	`306`	`notifier.shutdown();`
`307`	`307`	`// Elapsed`
`308`		`- assert!(matches!(notifier.wait_all_exit().await, Err(_)));`
	`308`	`+ assert!(notifier.wait_all_exit().await.is_err());`
`309`	`309`	`task.await.unwrap();`
`310`	`310`	`}`
`311`	`311`	`}`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ impl PipeListener {`
`112`	`112`	`let res = unsafe {GetOverlappedResult(np.named_pipe, ol.as_mut_ptr(), &mut bytes_transfered, WAIT_FOR_EVENT) };`
`113`	`113`	`match res {`
`114`	`114`	`0 => {`
`115`		`- return Err(io::Error::last_os_error());`
	`115`	`+ Err(io::Error::last_os_error())`
`116`	`116`	`}`
`117`	`117`	`_ => {`
`118`	`118`	`if let Some(shutdown_signal) = self.handle_shutdown(&np) {`
`@@ -129,10 +129,10 @@ impl PipeListener {`
`129`	`129`	`Ok(Some(np))`
`130`	`130`	`}`
`131`	`131`	`e => {`
`132`		`- return Err(io::Error::new(`
	`132`	`+ Err(io::Error::new(`
`133`	`133`	`io::ErrorKind::Other,`
`134`	`134`	`format!("failed to connect pipe: {:?}", e),`
`135`		`- ));`
	`135`	`+ ))`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`	`}`
`@@ -165,12 +165,12 @@ impl PipeListener {`
`165`	`165`	`// https://learn.microsoft.com/en-us/windows/win32/ipc/named-pipe-security-and-access-rights`
`166`	`166`	`match unsafe { CreateNamedPipeW(name.as_ptr(), open_mode, PIPE_WAIT \| PIPE_REJECT_REMOTE_CLIENTS, PIPE_UNLIMITED_INSTANCES, PIPE_BUFFER_SIZE, PIPE_BUFFER_SIZE, 0, std::ptr::null_mut())} {`
`167`	`167`	`INVALID_HANDLE_VALUE => {`
`168`		`- return Err(io::Error::last_os_error())`
	`168`	`+ Err(io::Error::last_os_error())`
`169`	`169`	`}`
`170`	`170`	`h => {`
`171`		`- return Ok(h)`
	`171`	`+ Ok(h)`
`172`	`172`	`},`
`173`		`- };`
	`173`	`+ }`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`pub fn close(&self) -> Result<()> {`
`@@ -208,8 +208,8 @@ impl PipeConnection {`
`208`	`208`	`let write_event = create_event()?;`
`209`	`209`	`Ok(PipeConnection {`
`210`	`210`	`named_pipe: h,`
`211`		`- read_event: read_event,`
`212`		`- write_event: write_event,`
	`211`	`+ read_event,`
	`212`	`+ write_event,`
`213`	`213`	`})`
`214`	`214`	`}`
`215`	`215`
`@@ -236,15 +236,15 @@ impl PipeConnection {`
`236`	`236`	`let res = unsafe {GetOverlappedResult(self.named_pipe, ol.as_mut_ptr(), &mut bytes_transfered, WAIT_FOR_EVENT) };`
`237`	`237`	`match res {`
`238`	`238`	`0 => {`
`239`		`- return Err(handle_windows_error(io::Error::last_os_error()))`
	`239`	`+ Err(handle_windows_error(io::Error::last_os_error()))`
`240`	`240`	`}`
`241`	`241`	`_ => {`
`242`		`- return Ok(bytes_transfered as usize)`
	`242`	`+ Ok(bytes_transfered as usize)`
`243`	`243`	`}`
`244`	`244`	`}`
`245`	`245`	`}`
`246`	`246`	`ref e => {`
`247`		`- return Err(Error::Others(format!("failed to read from pipe: {:?}", e)))`
	`247`	`+ Err(Error::Others(format!("failed to read from pipe: {:?}", e)))`
`248`	`248`	`}`
`249`	`249`	`}`
`250`	`250`	`}`
`@@ -267,15 +267,15 @@ impl PipeConnection {`
`267`	`267`	`let res = unsafe {GetOverlappedResult(self.named_pipe, ol.as_mut_ptr(), &mut bytes_transfered, WAIT_FOR_EVENT) };`
`268`	`268`	`match res {`
`269`	`269`	`0 => {`
`270`		`- return Err(handle_windows_error(io::Error::last_os_error()))`
	`270`	`+ Err(handle_windows_error(io::Error::last_os_error()))`
`271`	`271`	`}`
`272`	`272`	`_ => {`
`273`		`- return Ok(bytes_transfered as usize)`
	`273`	`+ Ok(bytes_transfered as usize)`
`274`	`274`	`}`
`275`	`275`	`}`
`276`	`276`	`}`
`277`	`277`	`ref e => {`
`278`		`- return Err(Error::Others(format!("failed to write to pipe: {:?}", e)))`
	`278`	`+ Err(Error::Others(format!("failed to write to pipe: {:?}", e)))`
`279`	`279`	`}`
`280`	`280`	`}`
`281`	`281`	`}`
`@@ -346,10 +346,10 @@ impl ClientConnection {`
`346`	`346`	`.custom_flags(FILE_FLAG_OVERLAPPED);`
`347`	`347`	`match opts.open(self.address.as_str()) {`
`348`	`348`	`Ok(file) => {`
`349`		`- return PipeConnection::new(file.into_raw_handle() as isize)`
	`349`	`+ PipeConnection::new(file.into_raw_handle() as isize)`
`350`	`350`	`}`
`351`	`351`	`Err(e) => {`
`352`		`- return Err(handle_windows_error(e))`
	`352`	`+ Err(handle_windows_error(e))`
`353`	`353`	`}`
`354`	`354`	`}`
`355`	`355`	`}`
`@@ -383,7 +383,7 @@ mod test {`
`383`	`383`	`let client = ClientConnection::new("non_existent_pipe");`
`384`	`384`	`match client.get_pipe_connection() {`
`385`	`385`	`Ok(_) => {`
`386`		`- assert!(false, "should not be able to get a connection to a non existent pipe");`
	`386`	`+ panic!("should not be able to get a connection to a non existent pipe");`
`387`	`387`	`}`
`388`	`388`	`Err(e) => {`
`389`	`389`	`assert_eq!(e, Error::Windows(ERROR_FILE_NOT_FOUND as i32));`
`@@ -404,10 +404,10 @@ mod test {`
`404`	`404`	`// pipe is working`
`405`	`405`	`}`
`406`	`406`	`Ok(None) => {`
`407`		`- assert!(false, "should get a working pipe")`
	`407`	`+ panic!("should get a working pipe")`
`408`	`408`	`}`
`409`	`409`	`Err(e) => {`
`410`		`- assert!(false, "should not get error {}", e.to_string())`
	`410`	`+ panic!("should not get error {}", e)`
`411`	`411`	`}`
`412`	`412`	`}`
`413`	`413`	`});`
`@@ -425,7 +425,7 @@ mod test {`
`425`	`425`	`let quit_flag = Arc::new(AtomicBool::new(false));`
`426`	`426`	`match listener_server.accept(&quit_flag) {`
`427`	`427`	`Ok(_) => {`
`428`		`- assert!(false, "should not get pipe on close")`
	`428`	`+ panic!("should not get pipe on close")`
`429`	`429`	`}`
`430`	`430`	`Err(e) => {`
`431`	`431`	`assert_eq!(e.to_string(), "closing pipe")`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+#![allow(dead_code)]`
`1`	`2`	`//! API to generate .rs files for ttrpc from protobuf`
`2`	`3`	`//!`
`3`	`4`	`//!`