Next/Prev message cycles through test errors.

Author: ehuss

cargo_build.py

@@ -196,7 +196,8 @@ def run(self):
             return
         messages.clear_messages(self.window)
         p = rust_proc.RustProc()
-        listener = opanel.OutputListener(self.window, self.working_dir)
+        listener = opanel.OutputListener(self.window, self.working_dir,
+                                         self.command_name)
         decode_json = util.get_setting('show_errors_inline', True) and \
             self.command_info.get('allows_json', False)
         try:

rust/messages.py

@@ -111,12 +111,15 @@ def add_message(window, path, span, level, is_main, text, markup_text, msg_cb):
         }
     messages = messages_by_path.setdefault(path, [])
 
-    phantom_text = PHANTOM_TEMPLATE.format(content=markup_text,
-        error_color=util.get_setting('rust_syntax_error_color', 'var(--redish)'),
-        warning_color=util.get_setting('rust_syntax_warning_color', 'var(--yellowish)'),
-        note_color=util.get_setting('rust_syntax_note_color', 'var(--greenish)'),
-        help_color=util.get_setting('rust_syntax_help_color', 'var(--bluish)'),
-    )
+    if markup_text:
+        phantom_text = PHANTOM_TEMPLATE.format(content=markup_text,
+            error_color=util.get_setting('rust_syntax_error_color', 'var(--redish)'),
+            warning_color=util.get_setting('rust_syntax_warning_color', 'var(--yellowish)'),
+            note_color=util.get_setting('rust_syntax_note_color', 'var(--greenish)'),
+            help_color=util.get_setting('rust_syntax_help_color', 'var(--bluish)'),
+        )
+    else:
+        phantom_text = None
     to_add = {
         'path': path,
         'level': level,
@@ -219,6 +222,8 @@ def check_in(region):
 def _show_phantom(view, level, span, message):
     if util.get_setting('rust_phantom_style', 'normal') == 'none':
         return
+    if not message:
+        return
     region = _span_to_region(view, span)
     # For some reason if you have a multi-line region, the phantom is only
     # displayed under the first line.  I think it makes more sense for the

rust/opanel.py

@@ -3,6 +3,7 @@
 import sublime
 
 import os
+import re
 from . import rust_proc, messages, util
 
 # Use the same panel name that Sublime's build system uses so that "Show Build
@@ -57,16 +58,42 @@ class OutputListener(rust_proc.ProcListener):
     # Sublime view used for output.
     output_view = None
 
-    def __init__(self, window, base_path):
+    def __init__(self, window, base_path, command_name):
         self.window = window
         self.base_path = base_path
+        self.command_name = command_name
 
     def on_begin(self, proc):
         self.output_view = create_output_panel(self.window, self.base_path)
         self._append('[Running: %s]' % (' '.join(proc.cmd),))
 
     def on_data(self, proc, data):
+        region_start = self.output_view.size()
         self._append(data, nl=False)
+        # Check for test errors.
+        if self.command_name == 'test':
+            # Re-fetch the data to handle things like \t expansion.
+            appended = self.output_view.substr(
+                sublime.Region(region_start, self.output_view.size()))
+            m = re.search(r', ([^,<\n]*\.[A-z]{2}):([0-9]+):([0-9]+)',
+                appended)
+            if m:
+                path = os.path.join(self.base_path, m.group(1))
+                lineno = int(m.group(2)) - 1
+                # Region columns appear to the left, so this is +1.
+                col = int(m.group(3))
+                span = ((lineno, col), (lineno, col))
+                # +2 to skip ", "
+                build_region = sublime.Region(region_start + m.start() + 2,
+                                              region_start + m.end())
+
+                # Use callback so the build output window scrolls to this
+                # point.
+                def on_test_cb(message):
+                    message['output_panel_region'] = build_region
+
+                messages.add_message(self.window, path, span, 'error', True,
+                    None, None, on_test_cb)
 
     def on_error(self, proc, message):
         self._append(message)

tests/message-order/tests/test_test_output.rs

@@ -0,0 +1,54 @@
+// Tests for cycling through the errors from a test run.
+
+#[test]
+fn passing() {
+}
+
+#[test]
+fn basic_error1() {
+    /*ERR 1 "tests/test_test_output.rs:9:46"*/assert!(false);
+}
+
+#[test]
+fn basic_error2() {
+    /*ERR 2 "tests/test_test_output.rs:14:47"*/assert_eq!(1, 0);
+}
+
+#[test]
+fn basic_error3() {
+    /*ERR 3 "tests/test_test_output.rs:19:47"*/assert_ne!(1, 1);
+}
+
+#[test]
+fn custom_message() {
+    /*ERR 4 "tests/test_test_output.rs:24:47"*/assert!(false, "Custom message");
+}
+
+#[test]
+fn manual_panic() {
+    /*ERR 5 "tests/test_test_output.rs:29:47"*/panic!("manual panic");
+}
+
+#[test]
+#[should_panic(expected="xyz")]
+fn expected_panic1() {
+    panic!("xyz");
+}
+
+#[test]
+#[should_panic(expected="xyz")]
+fn expected_panic2() {
+}
+
+#[test]
+#[ignore]
+fn ignored_test() {
+    panic!("ignored");
+}
+
+#[test]
+#[ignore]
+fn slow() {
+    // This just prints a simple warning.
+    std::thread::sleep(std::time::Duration::from_secs(65));
+}

tests/test_message_order.py

@@ -22,6 +22,9 @@ def setUp(self):
         window.run_command('cargo_set_target', {'target': 'auto',
                                                 'variant': 'build',
                                                 'package': pkg})
+        window.run_command('cargo_set_target', {'target': 'auto',
+                                                'variant': 'test',
+                                                'package': pkg})
 
     def test_message_order(self):
         """Test message order.
@@ -32,35 +35,36 @@ def test_message_order(self):
         The files are annotated with comments to indicate where each message
         should appear and in which order.  The annotations should look like:
 
-            /*ERR 1*/
-            /*WARN 2*/
+            /*ERR 1 "build_output_selection_inline" "build_output_selection_raw"*/
+            /*WARN 1 "build_output_selection_inline" "build_output_selection_raw"*/
 
         The number is the order the message should appear.  Two numbers can be
-        specified, where the second number is the "unsorted" sequence (the
-        order the message is emitted from rustc).
+        specified separated with a comma, where the second number is the
+        "unsorted" sequence (the order the message is emitted from rustc).
         """
         to_test = [
-            ('examples/ex_warning1.rs',
+            ('build', 'examples/ex_warning1.rs',
                 'examples/warning1.rs', 'examples/warning2.rs'),
-            ('tests/test_all_levels.rs',),
+            ('build', 'tests/test_all_levels.rs',),
+            ('test', 'tests/test_test_output.rs',),
         ]
-        for paths in to_test:
+        for command, *paths in to_test:
             rel_paths = [os.path.join('tests/message-order', path)
                 for path in paths]
             sorted_msgs, unsorted_msgs = self._collect_message_order(rel_paths)
             self.assertTrue(sorted_msgs)
             self.assertTrue(unsorted_msgs)
             self._with_open_file(rel_paths[0], self._test_message_order,
-                messages=sorted_msgs, inline=True)
+                messages=sorted_msgs, inline=True, command=command)
             self._with_open_file(rel_paths[0],
                 self._test_message_order, messages=unsorted_msgs,
-                inline=False)
+                inline=False, command=command)
 
-    def _test_message_order(self, view, messages, inline):
+    def _test_message_order(self, view, messages, inline, command):
         self._override_setting('show_errors_inline', inline)
         self._cargo_clean(view)
         window = view.window()
-        self._run_build_wait()
+        self._run_build_wait(command)
 
         def check_sequence(direction):
             omsgs = messages if direction == 'next' else reversed(messages)
@@ -105,7 +109,7 @@ def check_sequence(direction):
             # Test starting backwards.
             window.focus_view(view)
             self._cargo_clean(view)
-            self._run_build_wait()
+            self._run_build_wait(command)
             check_sequence('prev')
 
     def _collect_message_order(self, paths):
@@ -133,7 +137,7 @@ def _collect_message_order(self, paths):
                 [x[2:] for x in unsorted_result])
 
     def _collect_message_order_view(self, view, result):
-        pattern = r'/\*(ERR|WARN) ([0-9,]+) "([^"]+)" "([^"]+)"\*/'
+        pattern = r'/\*(ERR|WARN) ([0-9,]+) "([^"]+)"(?: "([^"]+)")?\*/'
         regions = view.find_all(pattern)
 
         def path_fixup(p):
@@ -152,7 +156,10 @@ def path_fixup(p):
                 sort_index = int(m.group(2))
                 unsorted = sort_index
             inline_highlight = path_fixup(m.group(3))
-            raw_highlight = path_fixup(m.group(4))
+            if m.group(4):
+                raw_highlight = path_fixup(m.group(4))
+            else:
+                raw_highlight = inline_highlight
             result.append((sort_index, unsorted, view.file_name(),
                 m.group(1), rowcol, inline_highlight, raw_highlight))