ah-diagnostics.H

Go to the documentation of this file.

/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
# ifndef AH_DIAGNOSTICS_H
# define AH_DIAGNOSTICS_H
 
# include <ostream>
# include <sstream>
# include <string>
 
# include <ah-source.H>
# include <tpl_dynArray.H>
 
namespace Aleph
{
  enum class Diagnostic_Severity
  {
    Note,
    Warning,
    Error,
    Fatal
  };
 
  enum class Diagnostic_Label_Kind
  {
    Primary,
    Secondary
  };
 
  struct Diagnostic_Label
  {
    Source_Span span; 
    Diagnostic_Label_Kind kind = Diagnostic_Label_Kind::Primary; 
    std::string message; 
  };
 
  struct Diagnostic
  {
    Diagnostic_Severity severity = Diagnostic_Severity::Error; 
    std::string code; 
    std::string message; 
    DynArray<Diagnostic_Label> labels; 
    DynArray<std::string> notes; 
    DynArray<std::string> help; 
  };
 
  class Diagnostic_Engine;
 
  class Diagnostic_Builder
  {
    Diagnostic_Engine * engine = nullptr;
    size_t diag_index = 0;
 
    Diagnostic & diag();
 
  public:
    Diagnostic_Builder(Diagnostic_Engine & engine, const size_t index) noexcept
      : engine(&engine), diag_index(index)
    {}
 
    Diagnostic_Builder & code(const std::string & value);
 
    Diagnostic_Builder & primary(const Source_Span & span,
                                 const std::string & msg = "");
 
    Diagnostic_Builder & secondary(const Source_Span & span,
                                   const std::string & msg);
 
    Diagnostic_Builder & note(const std::string & msg);
 
    Diagnostic_Builder & help(const std::string & msg);
 
    size_t emit() const noexcept
    {
      return diag_index;
    }
  };
 
  class Diagnostic_Engine
  {
    const Source_Manager * sources = nullptr;
    DynArray<Diagnostic> diags;
    size_t errors = 0;
    size_t warnings = 0;
 
    static const char * severity_string(const Diagnostic_Severity severity)
    {
      switch (severity)
        {
        case Diagnostic_Severity::Note: return "note";
        case Diagnostic_Severity::Warning: return "warning";
        case Diagnostic_Severity::Error: return "error";
        case Diagnostic_Severity::Fatal: return "fatal";
        }
 
      return "diagnostic";
    }
 
    size_t append_diagnostic(const Diagnostic_Severity severity,
                             const Source_Span & span,
                             const std::string & msg)
    {
      Diagnostic diag;
      diag.severity = severity;
      diag.message = msg;
      if (span.is_valid())
        diag.labels.append({span, Diagnostic_Label_Kind::Primary, ""});
 
      diags.append(std::move(diag));
      if (severity == Diagnostic_Severity::Warning)
        ++warnings;
      else if (severity == Diagnostic_Severity::Error
               or severity == Diagnostic_Severity::Fatal)
        ++errors;
 
      return diags.size() - 1;
    }
 
    const Diagnostic_Label *
    first_primary_label(const Diagnostic & diag) const noexcept
    {
      for (size_t i = 0; i < diag.labels.size(); ++i)
        {
          const auto & label = diag.labels.access(i);
          if (label.kind == Diagnostic_Label_Kind::Primary and label.span.is_valid())
            return &label;
        }
 
      for (size_t i = 0; i < diag.labels.size(); ++i)
        {
          const auto & label = diag.labels.access(i);
          if (label.span.is_valid())
            return &label;
        }
 
      return nullptr;
    }
 
    void render_label_snippet(std::ostream & out,
                              const Diagnostic_Label & label) const
    {
      if (not label.span.is_valid())
        return;
 
      const auto pos = sources->begin_position(label.span);
      const auto snip = sources->snippet(label.span);
 
      out << "  --> " << pos.to_string() << '\n';
 
      std::ostringstream ln;
      ln << snip.line;
      const std::string line_no = ln.str();
 
      out << " " << line_no << " | " << snip.line_text << '\n';
      out << " " << std::string(line_no.size(), ' ') << " | ";
      out << std::string(snip.highlight_column > 1 ? snip.highlight_column - 1 : 0, ' ');
      out << '^';
      for (size_t i = 1; i < snip.highlight_width; ++i)
        out << '~';
      if (not label.message.empty())
        out << " " << label.message;
      out << '\n';
    }
 
    void render_secondary_labels(std::ostream & out,
                                 const Diagnostic & diag) const
    {
      for (size_t i = 0; i < diag.labels.size(); ++i)
        {
          const auto & label = diag.labels.access(i);
          if (label.kind != Diagnostic_Label_Kind::Secondary)
            continue;
 
          out << "  = related";
          if (label.span.is_valid())
            out << ": " << sources->begin_position(label.span).to_string();
          if (not label.message.empty())
            out << ": " << label.message;
          out << '\n';
        }
    }
 
  public:
    explicit Diagnostic_Engine(const Source_Manager & sm) noexcept
      : sources(&sm)
    {}
 
    Diagnostic_Builder error(const Source_Span & span, const std::string & msg)
    {
      return Diagnostic_Builder(*this,
                                append_diagnostic(Diagnostic_Severity::Error,
                                                  span, msg));
    }
 
    Diagnostic_Builder warning(const Source_Span & span, const std::string & msg)
    {
      return Diagnostic_Builder(*this,
                                append_diagnostic(Diagnostic_Severity::Warning,
                                                  span, msg));
    }
 
    Diagnostic_Builder fatal(const Source_Span & span, const std::string & msg)
    {
      return Diagnostic_Builder(*this,
                                append_diagnostic(Diagnostic_Severity::Fatal,
                                                  span, msg));
    }
 
    Diagnostic_Builder note(const Source_Span & span, const std::string & msg)
    {
      return Diagnostic_Builder(*this,
                                append_diagnostic(Diagnostic_Severity::Note,
                                                  span, msg));
    }
 
    const Diagnostic & get(const size_t i) const
    {
      ah_out_of_range_error_unless(i < diags.size())
        << "Diagnostic_Engine::get(): invalid index " << i;
      return diags.access(i);
    }
 
    size_t size() const noexcept
    {
      return diags.size();
    }
 
    size_t error_count() const noexcept
    {
      return errors;
    }
 
    size_t warning_count() const noexcept
    {
      return warnings;
    }
 
    bool has_errors() const noexcept
    {
      return errors > 0;
    }
 
    void clear() noexcept
    {
      diags.clear();
      errors = 0;
      warnings = 0;
    }
 
    void render_plain(std::ostream & out) const
    {
      for (size_t i = 0; i < diags.size(); ++i)
        {
          const auto & diag = diags.access(i);
          out << severity_string(diag.severity);
          if (not diag.code.empty())
            out << "[" << diag.code << "]";
          out << ": " << diag.message << '\n';
 
          if (const auto * primary = first_primary_label(diag);
              primary != nullptr)
            render_label_snippet(out, *primary);
 
          render_secondary_labels(out, diag);
 
          for (size_t j = 0; j < diag.notes.size(); ++j)
            out << "  = note: " << diag.notes.access(j) << '\n';
 
          for (size_t j = 0; j < diag.help.size(); ++j)
            out << "  = help: " << diag.help.access(j) << '\n';
 
          if (i + 1 < diags.size())
            out << '\n';
        }
    }
 
    friend class Diagnostic_Builder;
  };
 
  inline Diagnostic &
  Diagnostic_Builder::diag()
  {
    ah_runtime_error_unless(engine != nullptr)
      << "Diagnostic_Builder: detached builder";
    return engine->diags.access(diag_index);
  }
 
  inline Diagnostic_Builder &
  Diagnostic_Builder::code(const std::string & value)
  {
    diag().code = value;
    return *this;
  }
 
  inline Diagnostic_Builder &
  Diagnostic_Builder::primary(const Source_Span & span, const std::string & msg)
  {
    diag().labels.append({span, Diagnostic_Label_Kind::Primary, msg});
    return *this;
  }
 
  inline Diagnostic_Builder &
  Diagnostic_Builder::secondary(const Source_Span & span, const std::string & msg)
  {
    diag().labels.append({span, Diagnostic_Label_Kind::Secondary, msg});
    return *this;
  }
 
  inline Diagnostic_Builder &
  Diagnostic_Builder::note(const std::string & msg)
  {
    diag().notes.append(msg);
    return *this;
  }
 
  inline Diagnostic_Builder &
  Diagnostic_Builder::help(const std::string & msg)
  {
    diag().help.append(msg);
    return *this;
  }
}
 
# endif // AH_DIAGNOSTICS_H