fix(cli): propagate verbose compiler diagnostics

Author: GaspardKirira

include/vix/cli/ErrorHandler.hpp

@@ -23,6 +23,13 @@ namespace vix::cli
   class ErrorHandler
   {
   public:
+    static bool printBuildErrors(
+        const std::string &buildLog,
+        const fs::path &sourceFile,
+        const std::string &contextMessage,
+        bool verbose);
+
+    // Compatibility overload for callers that do not expose a verbose mode.
     static bool printBuildErrors(
         const std::string &buildLog,
         const fs::path &sourceFile,

include/vix/cli/errors/BuildFailureClassification.hpp

@@ -0,0 +1,60 @@
+/**
+ *  @file BuildFailureClassification.hpp
+ *  @brief Small, log-only guards used before selecting a build failure class.
+ */
+#ifndef VIX_BUILD_FAILURE_CLASSIFICATION_HPP
+#define VIX_BUILD_FAILURE_CLASSIFICATION_HPP
+
+#include <cctype>
+#include <string_view>
+
+namespace vix::cli::errors
+{
+  inline bool contains_source_compiler_diagnostic(std::string_view log) noexcept
+  {
+    std::size_t lineStart = 0;
+
+    while (lineStart < log.size())
+    {
+      const std::size_t lineEnd = log.find('\n', lineStart);
+      const std::string_view line = log.substr(
+          lineStart,
+          (lineEnd == std::string_view::npos ? log.size() : lineEnd) - lineStart);
+      const std::size_t error = line.find(": error:");
+      const std::size_t fatal = line.find(": fatal error:");
+      const std::size_t marker = error != std::string_view::npos ? error : fatal;
+
+      if (marker != std::string_view::npos)
+      {
+        const std::string_view location = line.substr(0, marker);
+        const std::size_t columnColon = location.rfind(':');
+        const std::size_t lineColon =
+            columnColon == std::string_view::npos
+                ? std::string_view::npos
+                : location.rfind(':', columnColon == 0 ? 0 : columnColon - 1);
+
+        const auto is_number = [](std::string_view value)
+        {
+          return !value.empty() &&
+                 value.find_first_not_of("0123456789") == std::string_view::npos;
+        };
+
+        if (columnColon != std::string_view::npos &&
+            lineColon != std::string_view::npos &&
+            is_number(location.substr(columnColon + 1)) &&
+            is_number(location.substr(lineColon + 1, columnColon - lineColon - 1)))
+        {
+          return true;
+        }
+      }
+
+      if (lineEnd == std::string_view::npos)
+        break;
+      lineStart = lineEnd + 1;
+    }
+
+    return false;
+  }
+} // namespace vix::cli::errors
+
+#endif

include/vix/cli/errors/CompilerDiagnosticPresentation.hpp

@@ -0,0 +1,32 @@
+/**
+ *  @file CompilerDiagnosticPresentation.hpp
+ *  @brief Presentation limits for parsed compiler diagnostics.
+ */
+#ifndef VIX_COMPILER_DIAGNOSTIC_PRESENTATION_HPP
+#define VIX_COMPILER_DIAGNOSTIC_PRESENTATION_HPP
+
+#include <cstddef>
+
+namespace vix::cli::errors
+{
+  struct CompilerDiagnosticPresentation
+  {
+    std::size_t shown = 0;
+    std::size_t hidden = 0;
+
+    [[nodiscard]] bool show_verbose_hint() const noexcept
+    {
+      return hidden != 0;
+    }
+  };
+
+  inline CompilerDiagnosticPresentation compiler_diagnostic_presentation(
+      std::size_t total,
+      bool verbose) noexcept
+  {
+    const std::size_t shown = verbose ? total : (total == 0 ? 0 : 1);
+    return {shown, total - shown};
+  }
+} // namespace vix::cli::errors
+
+#endif

src/ErrorHandler.cpp

@@ -16,6 +16,7 @@
 #include <vix/cli/errors/ClangGccParser.hpp>
 #include <vix/cli/errors/CodeFrame.hpp>
 #include <vix/cli/errors/CompilerError.hpp>
+#include <vix/cli/errors/CompilerDiagnosticPresentation.hpp>
 #include <vix/cli/errors/ErrorContext.hpp>
 #include <vix/cli/errors/ErrorPipeline.hpp>
 #include <vix/cli/errors/RawLogDetectors.hpp>
@@ -259,6 +260,19 @@ namespace vix::cli
       const std::string &buildLog,
       const fs::path &sourceFile,
       const std::string &contextMessage)
+  {
+    return printBuildErrors(
+        buildLog,
+        sourceFile,
+        contextMessage,
+        false);
+  }
+
+  bool ErrorHandler::printBuildErrors(
+      const std::string &buildLog,
+      const fs::path &sourceFile,
+      const std::string &contextMessage,
+      bool verbose)
   {
     using namespace vix::cli::errors;
 
@@ -333,7 +347,10 @@ namespace vix::cli
     ErrorContext ctx{sourceFile, contextMessage, buildLog};
     ErrorPipeline pipeline;
 
-    if (pipeline.tryHandle(errors, ctx))
+    // Focused rules are intentionally concise. For a diagnostic batch they
+    // can select a secondary cascading error; render the first parsed error
+    // instead. Verbose mode always renders the complete parsed set.
+    if (!verbose && errors.size() == 1 && pipeline.tryHandle(errors, ctx))
       return true;
 
     std::vector<CompilerError> unique;
@@ -374,15 +391,8 @@ namespace vix::cli
       return false;
     }
 
-    /*
-     * Show the first compiler error by default.
-     *
-     * Compiler errors frequently cascade: once the parser cannot
-     * understand one declaration, it may report several secondary
-     * errors. Showing the first error keeps the output focused for
-     * beginners.
-     */
-    const std::size_t maxToShow = 1;
+    const CompilerDiagnosticPresentation presentation =
+        compiler_diagnostic_presentation(unique.size(), verbose);
 
     CodeFrameOptions codeFrameOptions;
     codeFrameOptions.contextLines = 1;
@@ -391,7 +401,7 @@ namespace vix::cli
     codeFrameOptions.leadingBlankLine = false;
 
     for (std::size_t i = 0;
-         i < unique.size() && i < maxToShow;
+         i < presentation.shown;
          ++i)
     {
       const CompilerError &err = unique[i];
@@ -420,17 +430,12 @@ namespace vix::cli
         print_hint(hint);
     }
 
-    const std::size_t hiddenCount =
-        unique.size() > maxToShow
-            ? unique.size() - maxToShow
-            : 0;
-
-    if (hiddenCount > 0)
+    if (presentation.show_verbose_hint())
     {
       std::cerr << MUTED
-                << hiddenCount
+                << presentation.hidden
                 << " more compiler error"
-                << (hiddenCount == 1 ? "" : "s")
+                << (presentation.hidden == 1 ? "" : "s")
                 << " hidden. Run with --verbose to see them."
                 << RESET
                 << "\n";

src/commands/BuildCommand.cpp

@@ -3721,17 +3721,17 @@ namespace vix::commands::BuildCommand
       return value == "debug" || value == "trace";
     }
 
-    static void print_debug_command_if_enabled(
+    static void print_failure_command_if_requested(
         const process::Options &opt,
         const process::ExecResult &result)
     {
-      if (!debug_build_details_enabled(opt))
+      if (!opt.verbose && !debug_build_details_enabled(opt))
         return;
 
       if (result.displayCommand.empty())
         return;
 
-      std::cerr << GRAY
+      std::cerr << LABEL
                 << "command: "
                 << RESET
                 << result.displayCommand
@@ -5836,7 +5836,8 @@ namespace vix::commands::BuildCommand
                 vix::cli::ErrorHandler::printBuildErrors(
                     log,
                     plan_.cmakeSourceDir / "CMakeLists.txt",
-                    "CMake configure failed");
+                    "CMake configure failed",
+                    opt_.verbose);
 
             if (!handled && opt_.verbose && !log.empty())
             {
@@ -5849,7 +5850,7 @@ namespace vix::commands::BuildCommand
               if (!handled)
                 hint("run `vix build --log configure` for the captured configure output");
 
-              print_debug_command_if_enabled(opt_, r);
+              print_failure_command_if_requested(opt_, r);
             }
 
             return exitCode;
@@ -6197,8 +6198,7 @@ namespace vix::commands::BuildCommand
 
           const bool legacyBuildQuiet =
               opt_.quiet ||
-              (liveBuild &&
-               !showRawBuildOutput);
+              !showRawBuildOutput;
 
           const process::ExecResult r =
               measurePhase(
@@ -6245,14 +6245,15 @@ namespace vix::commands::BuildCommand
                 vix::cli::ErrorHandler::printBuildErrors(
                     log,
                     plan_.cmakeSourceDir / "CMakeLists.txt",
-                    "Build failed");
+                    "Build failed",
+                    opt_.verbose);
 
             if (!opt_.quiet)
             {
               if (!handled)
                 hint("run `vix build --log build` for the captured build output");
 
-              print_debug_command_if_enabled(opt_, r);
+              print_failure_command_if_requested(opt_, r);
             }
             return exitCode;
           }

src/errors/RawLogDetectors.cpp

@@ -12,6 +12,7 @@
  *
  */
 #include <vix/cli/errors/RawLogDetectors.hpp>
+#include <vix/cli/errors/BuildFailureClassification.hpp>
 #include <vix/cli/errors/CodeFrame.hpp>
 #include <vix/cli/errors/CompilerError.hpp>
 #include <vix/cli/errors/runtime/IRuntimeErrorRule.hpp>
@@ -885,6 +886,12 @@ namespace vix::cli::errors
       const std::filesystem::path &sourceFile,
       [[maybe_unused]] const std::string &contextMessage)
   {
+    // A failed incremental Ninja invocation can still contain a stale linker
+    // line. A source-location compiler diagnostic is stronger evidence and
+    // must not be presented as a link failure.
+    if (contains_source_compiler_diagnostic(buildLog))
+      return false;
+
     if (handleLinkerErrors(buildLog, sourceFile))
       return true;
 

tests/CMakeLists.txt

@@ -63,6 +63,17 @@ target_include_directories(vix_cli_clang_gcc_parser_tests PRIVATE
 )
 add_test(NAME vix_cli_clang_gcc_parser_tests COMMAND vix_cli_clang_gcc_parser_tests)
 
+add_executable(vix_cli_compiler_diagnostic_presentation_tests
+  CompilerDiagnosticPresentationTests.cpp
+)
+target_include_directories(vix_cli_compiler_diagnostic_presentation_tests PRIVATE
+  ${CMAKE_CURRENT_SOURCE_DIR}/../include
+)
+add_test(
+  NAME vix_cli_compiler_diagnostic_presentation_tests
+  COMMAND vix_cli_compiler_diagnostic_presentation_tests
+)
+
 add_executable(vix_cli_git_progress_parser_tests GitProgressParserTests.cpp)
 target_include_directories(vix_cli_git_progress_parser_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../include)
 add_test(NAME vix_cli_git_progress_parser_tests COMMAND vix_cli_git_progress_parser_tests)

tests/CompilerDiagnosticPresentationTests.cpp

@@ -0,0 +1,26 @@
+#include <vix/cli/errors/BuildFailureClassification.hpp>
+#include <vix/cli/errors/CompilerDiagnosticPresentation.hpp>
+
+#include <stdexcept>
+
+int main()
+{
+  using namespace vix::cli::errors;
+
+  const auto concise = compiler_diagnostic_presentation(8, false);
+  if (concise.shown != 1 || concise.hidden != 7 || !concise.show_verbose_hint())
+    throw std::runtime_error("default diagnostics must remain concise");
+
+  const auto verbose = compiler_diagnostic_presentation(8, true);
+  if (verbose.shown != 8 || verbose.hidden != 0 || verbose.show_verbose_hint())
+    throw std::runtime_error("verbose diagnostics must show every parsed error");
+
+  const char *compilerThenStaleLinker =
+      "/tmp/project/main.cpp:12:9: error: invalid expression\n"
+      "collect2: error: ld returned 1 exit status\n";
+  if (!contains_source_compiler_diagnostic(compilerThenStaleLinker))
+    throw std::runtime_error("source compiler diagnostics must win over stale linker output");
+
+  if (contains_source_compiler_diagnostic("mold: error: undefined symbol: main\n"))
+    throw std::runtime_error("a linker-only failure is not a compiler diagnostic");
+}