feat(compilation): improve compile error handling and protocol

- Automatically send compile errors after CompilationFinished message
- Simplify compile error collection in UnityManager
- Update documentation for new compilation protocol behavior
- Refactor test assertions for compile error handling
- Remove redundant compile error collection delay logic

Author: hackerzhuli

UnityProject/Packages/packages-lock.json

@@ -9,7 +9,7 @@
         "com.unity.nuget.newtonsoft-json": "3.2.1",
         "com.unity.nuget.mono-cecil": "1.11.4"
       },
-      "hash": "9257ab7d15c0d166e59f2af8054a570a0cb5b58b"
+      "hash": "41cea8e4958084e43e1bbb957a177dcc51698ac7"
     },
     "com.unity.burst": {
       "version": "1.8.21",

docs/UnityPackageMessagingProtocol.md

@@ -72,13 +72,13 @@ All available message types:
 | `RetrieveTestList` | 23 | Request to retrieve list of available tests | Test mode string ("EditMode" or "PlayMode") |
 | `ExecuteTests` | 24 | Request to execute specific tests | TestMode, TestMode:AssemblyName.dll, or TestMode:FullTestName / Response is empty string|
 | `ShowUsage` | 25 | Show usage information | JSON serialized FileUsage object |
-| `CompilationFinished` | 100 | Notification that compilation has finished | Empty string |
+| `CompilationFinished` | 100 | Notification that compilation has finished | Empty string (automatically followed by GetCompileErrors message) |
 | `PackageName` | 101 | Request/response for package name | Empty string (request) / Package name string (response) |
 | `Online` | 102 | Notifies clients that this package is online and ready to receive messages | Empty string |
 | `Offline` | 103 | Notifies clients that this package is offline and can not receive messages | Empty string |
 | `IsPlaying` | 104 | Notification of current play mode state | "true" (in play mode) / "false" (in edit mode) |
 | `CompilationStarted` | 105 | Notification that compilation has started | Empty string |
-| `GetCompileErrors` | 106 | Request/response for compile error information | Empty string (request) / JSON serialized LogContainer (response) |
+| `GetCompileErrors` | 106 | Auto-sent after CompilationFinished, or manual request/response for compile error information | Empty string (request) / JSON serialized LogContainer (response) |
 
 Note:
 - Message value greater than or equal to 100 means it does not exist in the official package but was added in this package.
@@ -130,11 +130,26 @@ Detailed value formats for some of the types:
   - **Compilation Lifecycle**: This message is sent at the beginning of the compilation process, before any assembly compilation starts
   - **Relationship to CompilationFinished**: This message pairs with `CompilationFinished` (Value: 100) to provide complete compilation lifecycle notifications
 
+#### CompilationFinished (Value: 100)
+- **Format**: Empty string
+- **Description**: Notification sent when Unity's compilation pipeline finishes compiling assemblies. This message is broadcast to all connected clients when the compilation process completes.
+- **Automatic Behavior**: 
+  - **GetCompileErrors Auto-Send**: Immediately after broadcasting this message, a `GetCompileErrors` message (Value: 106) is automatically sent to all connected clients with the collected compile errors from the compilation session
+  - **Error Collection**: Compile errors are collected during the compilation process and automatically provided without requiring a separate request
+  - **Manual Requests**: `GetCompileErrors` can still be requested manually
+- **Important Notes**:
+  - **Compilation Lifecycle**: This message is sent at the end of the compilation process, after all assembly compilation finishes
+  - **Relationship to CompilationStarted**: This message pairs with `CompilationStarted` (Value: 105) to provide complete compilation lifecycle notifications
+  - **Client Integration**: Clients can expect to receive compile error information automatically after each compilation without needing to explicitly request it
+
 #### GetCompileErrors (Value: 106)
 - **Format**: 
   - Request: Empty string
   - Response: JSON serialized LogContainer object
-- **Description**: Requests the collected compile errors that occurred during Unity's compilation process. Unity collects compile errors within a 1-second window after compilation finishes.
+- **Description**: Provides the collected compile errors that occurred during Unity's compilation process. This message is automatically sent to all connected clients immediately after each `CompilationFinished` message, but can also be requested manually.
+- **Automatic Behavior**: 
+  - **Auto-Send**: Automatically broadcast to all clients after every `CompilationFinished` message
+  - **Manual Request**: Can also be requested manually by sending an empty string request
 
 - **C# Structure**:
 
@@ -173,7 +188,7 @@ public class Log
   - **Error Filtering**: Only log messages containing "error CS" are collected
   - **Automatic Clearing**: Previous compile errors are cleared when compilation starts
   - **Response Format**: Returns JSON with LogContainer containing array of Log objects
-- **Usage**: Clients can request this to get structured compile error information for IDE integration, error highlighting, and debugging assistance.
+- **Usage**: Clients automatically receive structured compile error information after each compilation for IDE integration, error highlighting, and debugging assistance. Manual requests are also supported for on-demand error retrieval.
 
 #### RetrieveTestList (Value: 23)
 - **Format**: Test mode string ("EditMode" or "PlayMode")
@@ -185,11 +200,20 @@ public class Log
   - `TestMode` - Execute all tests in the specified mode
   - `TestMode:AssemblyName.dll` - Execute all tests in the specified assembly
   - `TestMode:FullTestName` - Execute a specific test by its full name
+  - `TestMode:PartialTestName?` - Execute tests using fuzzy matching (partial name matching), by ending with `?`
 - **Examples**: 
   - `"EditMode"` - Run all edit mode tests
   - `"PlayMode:MyTests.dll"` - Run all tests in MyTests assembly
   - `"EditMode:MyNamespace.MyTestClass"` - Run all tests in MyTestClass
-- **Description**: Executes tests based on the specified filter. The filter can target all tests in a mode, all tests in an assembly, or a specific test by name.
+  - `"EditMode:TestMethod?"` - Run all tests whose full name ends with "TestMethod"
+  - `"PlayMode:Utils?"` - Run all tests whose full name ends with "Utils"
+- **Description**: Executes tests based on the specified filter. The filter can target all tests in a mode, all tests in an assembly, or a specific test by name. When the filter doesn't match any exact test names, fuzzy matching is performed to find tests whose full names end with the specified search term.
+- **Fuzzy Matching Behavior**:
+  - If filter ends with `?`, the system performs fuzzy matching
+  - Fuzzy matching finds all tests (including non-leaf nodes) whose `FullName` ends with the search term
+  - Case-insensitive matching is used
+  - Both leaf tests and test containers (classes, namespaces) can be matched
+  - Multiple matches are supported - all matching tests will be executed
 
 Response:
 - A response that is empty is sent to the original client to confirm that the message is received and already processed.

src/unity_manager.rs

@@ -237,45 +237,22 @@ impl UnityManager {
                                 {
                                     *compilation_guard = Some(compilation_finish_time);
                                 }
-
-                                // Wait 1 second for logs to arrive after compilation finish event
-                                let log_manager_clone = log_manager.clone();
-                                let last_compile_errors_clone = last_compile_errors.clone();
-                                tokio::spawn(async move {
-                                    // give it a little bit more time, 3 seconds to make sure we don't miss any logs
-                                    tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
-                                    
-                                    // Collect compile errors from logs
-                                    if let Ok(log_manager_guard) = log_manager_clone.lock() {
-                                        if let Ok(mut compile_errors_guard) = last_compile_errors_clone.lock()
-                                        {
-                                            // start a bit earlier than compilation finish time in case messages are not received in order
-                                            let logs = log_manager_guard.get_recent_logs(compilation_finish_time - Duration::from_secs(1), Some(LogLevel::Error), Some("error CS"));
-                                            for log_entry in logs {
-                                                let main_message =
-                                                    extract_main_message(&log_entry.message);
-                                                compile_errors_guard.push(main_message);
-                                            }
-                                            debug_log!("Compilation finished - collected {} compile errors: {:?}", compile_errors_guard.len(), compile_errors_guard);
-                                        }
-                                    }
-                                });
                             }
                             UnityEvent::CompileErrors(log_container) => {
-                                // Handle initial compile errors from Unity
-                                // If we never received compile finish events
-                                // then this is the initial compile errors before we connect to Unity
+                                // Handle compile errors from Unity
+                                // Update compile errors whenever we receive them
+                                if let Ok(mut compile_errors_guard) = last_compile_errors.lock() {
+                                    compile_errors_guard.clear();
+                                    for log in &log_container.logs {
+                                        let main_message = extract_main_message(&log.message);
+                                        compile_errors_guard.push(main_message);
+                                    }
+                                    debug_log!("Compile errors received from Unity: {} errors", compile_errors_guard.len());
+                                }
+
+                                // If this is the first time we receive compile errors, set the compilation finished time
                                 if let Ok(mut last_compilation_finished_guard) = last_compilation_finished.lock() {
                                     if last_compilation_finished_guard.is_none() {
-                                        if let Ok(mut compile_errors_guard) = last_compile_errors.lock() {
-                                            compile_errors_guard.clear();
-                                            for log in &log_container.logs {
-                                                let main_message = extract_main_message(&log.message);
-                                                compile_errors_guard.push(main_message);
-                                            }
-                                            debug_log!("Initial compile errors received from Unity: {} errors", compile_errors_guard.len());
-                                        }
-
                                         // compile didn't happen just now, but we can use now as a fake compile time, it's ok
                                         *last_compilation_finished_guard = Some(SystemTime::now());
                                     }
@@ -697,56 +674,13 @@ impl UnityManager {
                 }
             }
 
-            // Wait additional time for compile errors to arrive after compilation finishes
+            // Wait a fixed 100ms for compile errors to arrive after compilation finishes
             if refresh_task.is_successful() && refresh_task.has_compilation() {
-                // Wait for either Unity to go offline (domain reload = compilation success)
-                // or compile errors to arrive (compilation failed)
-                let mut received_compile_errors = false;
-                let wait_timeout = Duration::from_secs(3); // 3 second timeout for waiting
-                let wait_start = std::time::Instant::now();
-                
-                while wait_start.elapsed() < wait_timeout {
-                    match timeout(Duration::from_millis(100), event_receiver.recv()).await {
-                        Ok(Ok(event)) => {
-                            match event {
-                                UnityEvent::OnlineStateChanged(is_online) => {
-                                    if !is_online {
-                                        // Unity went offline -> domain reload happened -> compilation success!
-                                        debug_log!("Unity went offline, domain reload detected - compilation successful");
-                                        break;
-                                    }
-                                }
-                                UnityEvent::LogMessage { level: LogLevel::Error, message } => {
-                                    // Check if this is a compile error log -> compilation failed
-                                    if message.contains("error CS") {
-                                        debug_log!("Compile error detected in log message - compilation failed");
-                                        received_compile_errors = true;
-                                        break;
-                                    }
-                                }
-                                _ => {
-                                    // Ignore other events
-                                }
-                            }
-                        }
-                        Ok(Err(_)) => {
-                            // Event channel closed
-                            break;
-                        }
-                        Err(_) => {
-                            // Timeout, continue waiting
-                        }
-                    }
-                }
-                
-                // Give a small additional delay if we received compile errors to ensure all are collected
-                if received_compile_errors {
-                    sleep(Duration::from_millis(100)).await;
-                }
+                sleep(Duration::from_millis(200)).await;
             }
 
-            let previous_compile_errors = self.get_last_compile_errors();
-            let result = refresh_task.build_result(&self.log_manager, &previous_compile_errors);
+            let compile_errors = self.get_last_compile_errors();
+            let result = refresh_task.build_result(&self.log_manager, &compile_errors);
             Ok(result)
         } else {
             Err(MESSAGING_CLIENT_NOT_INIT_ERROR.into())

src/unity_manager_tests.rs

@@ -137,7 +137,7 @@ async fn execute_unity_tests_with_validation(
         .map_err(|_| "Unity Editor not running or messaging failed")?;
 
     // Wait for Unity to become online
-    manager.wait_online(3).await
+    manager.wait_online(10).await
         .map_err(|e| format!("Timeout waiting for Unity to become online: {}", e))?;
     println!("✓ Unity connectivity confirmed");
 
@@ -294,24 +294,17 @@ async fn test_unity_manager_refresh_with_compilation_errors() {
             assert!(result.success, "Refresh should have completed successfully");
             assert!(result.refresh_error_message.is_none(), "Refresh should not have error message: {:?}", result.refresh_error_message);
 
-            // Verify we received compilation error logs
-            assert!(!result.problems.is_empty(), "Should have received compilation error logs");
+            // Check that we have compilation errors
+            println!("Problems: {:?}", result.problems);
+            assert!(!result.problems.is_empty(), "Should have compilation errors");
 
-            // Check that the error logs contain compilation-related errors
-            let compilation_errors: Vec<_> = result.problems.iter().filter(|log| {
-                let msg_lower = log.to_lowercase();
-                msg_lower.contains("error") || 
-                msg_lower.contains("compilation") ||
-                msg_lower.contains("testcompilationerrors") ||
-                msg_lower.contains("nonexistentnamespace") ||
-                msg_lower.contains("undefinedvariable") ||
-                msg_lower.contains("cs(") // C# error format usually contains "cs(line,col)"
-            }).collect();
+            // Should contain compilation-related errors
+            let has_compilation_error = result.problems.iter().any(|problem| {
+                problem.contains("error CS") || problem.contains("compilation")
+            });
+            assert!(has_compilation_error, "Should contain compilation-related errors");
 
-            assert!(!compilation_errors.is_empty(), 
-                   "Should have received compilation-related error logs. Received logs: {:?}", result.problems);
-            
-            println!("✓ Received {} compilation-related error logs", compilation_errors.len());
+            println!("✓ Received {} compilation-related error logs", result.problems.len());
 
             // Print some of the error logs for debugging
             for (i, log) in result.problems.iter().take(3).enumerate() {
@@ -336,10 +329,11 @@ async fn test_unity_manager_refresh_with_compilation_errors() {
             // Verify middle refresh completed successfully
             assert!(result.success, "Middle refresh should have completed successfully");
 
-            // Verify we still received compilation error logs from previous compile
-            assert!(!result.problems.is_empty(), "Middle refresh should still receive compilation error logs from previous compile");
+            // With the new protocol, compile errors come from dedicated messages.
+            // The problems field contains previous compile errors, which should still be available.
+            assert!(!result.problems.is_empty(), "Middle refresh should still receive compilation error logs from previous compile errors");
 
-            println!("✓ Middle refresh received {} compilation-related error logs from previous compile", result.problems.len());
+            println!("✓ Middle refresh received {} compilation-related error logs from previous compile errors", result.problems.len());
         },
         Err(e) => {
             println!("⚠ Middle refresh method failed: {}", e);

src/unity_refresh_task.rs

@@ -138,15 +138,13 @@ impl UnityRefreshAssetDatabaseTask {
     pub fn build_result(
         &self,
         log_manager: &std::sync::Arc<std::sync::Mutex<UnityLogManager>>,
-        previous_compile_errors: &[String],
+        compile_errors: &[String],
     ) -> RefreshResult {
-        let mut logs = self.collect_refresh_logs(log_manager);
-        
-        // If no compilation occurred during this refresh, include previous compile errors
-        if !self.is_compile && !previous_compile_errors.is_empty() {
-            logs.extend_from_slice(previous_compile_errors);
-        }
-        
+        let mut logs = Vec::new();
+        logs.extend_from_slice(compile_errors);
+        let other_logs = self.collect_refresh_logs(log_manager);
+        logs.extend(other_logs);
+
         let duration = self.operation_start.elapsed().as_secs_f64();
 
         RefreshResult {
@@ -165,12 +163,13 @@ impl UnityRefreshAssetDatabaseTask {
     ) -> Vec<String> {
         let mut logs: Vec<String> = Vec::new();
 
-        // Get errors and warnings during this refresh (excluding CS warnings because there can be too many)
+        // Get errors and warnings during this refresh (excluding CS warnings and compile errors)
         if let Ok(log_manager_guard) = log_manager.lock() {
             let recent_logs = log_manager_guard.get_recent_logs(self.refresh_start_time, None, None);
 
             for log in recent_logs {
                 if !log.message.contains("warning CS")
+                    && !log.message.contains("error CS")
                     && (log.level == LogLevel::Error || log.level == LogLevel::Warning)
                 {
                     logs.push(extract_main_message(log.message.as_str()));