Utilities.h

Go to the documentation of this file.

#pragma once
#include "fmt/color.h"
#include "fmt/core.h"
#include <algorithm>
#include <cassert>
#include <cstdlib>
#include <iostream>
#include <filesystem>
#include <source_location>
#include <string>
#include <string_view>
#include <tuple>
#include <unistd.h>
#include <utility>
#include <vector>
#include <memory>

 
namespace sammine_util {
inline bool stderr_is_tty() {
  static const bool is_tty = ::isatty(STDERR_FILENO);
  return is_tty;
}
inline fmt::text_style styled(fmt::terminal_color c) {
  return stderr_is_tty() ? fg(c) : fmt::text_style{};
}
 
 
auto get_string_from_file(const std::string &file_name) -> std::string;
 
template <typename T>
concept explicitly_bool_like = requires(T t) {
  { static_cast<bool>(t) } -> std::same_as<bool>;
};
[[noreturn]] auto abort(const std::string &message = "<NO MESSAGE>") -> void;
 
template <explicitly_bool_like T>
void abort_on(const T &condition, const std::string &message = "<NO MESSAGE>") {
  if (static_cast<bool>(condition)) {
    abort(message);
  }
}
 
template <explicitly_bool_like T>
void abort_if_not(const T &condition,
                  const std::string &message = "<NO MESSAGE>") {
  if (!static_cast<bool>(condition)) {
    abort(message);
  }
}
inline void log_diagnostics(const std::string &diagnostics) {
  fmt::print(stderr, fg(fmt::terminal_color::green), "{}\n", diagnostics);
}
 
struct SourceInfo {
  std::string file_name;
  std::string source_text;
};


class Location {
public:
  // True location in original source code string
  int64_t source_start, source_end;
 
  // Source file info (nullptr = main file)
  std::shared_ptr<SourceInfo> source_info;
 
  // Default constructor
  Location() : source_start(0), source_end(0) {}
  static Location NonPrintable() { return Location(-1, -1); }
  Location(int64_t source_start, int64_t source_end)
      : source_start(source_start), source_end(source_end) {}
 
  // Advance column position
  inline void advance() { source_end++; }
 
  // Move column position backwards
  inline void devance() {
    source_end--;
    assert(source_end >= source_start);
  }
 
  // Handle newline
  inline void newLine() { advance(); }
 
  // Combine two locations — propagate non-null source_info
  Location operator|(const Location &other) const {
    Location result;
    result.source_start = std::min(source_start, other.source_start);
    result.source_end = std::max(source_end, other.source_end);
    result.source_info = source_info ? source_info : other.source_info;
    return result;
  }
 
  void operator|=(const Location &other) {
    source_start = std::min(source_start, other.source_start);
    source_end = std::max(source_end, other.source_end);
    if (!source_info)
      source_info = other.source_info;
  }
 
  std::pair<int64_t, int64_t> as_pair() const {
    return std::make_pair(source_start, source_end);
  }
 
  // Stream output operator
  friend std::ostream &operator<<(std::ostream &out, const Location &loc) {
    out << loc.source_start << ":" << loc.source_end;
 
    return out;
  }
 
  // Equality operator
  bool operator==(const Location &other) const {
    return source_start == other.source_start &&
           source_end == other.source_end &&
           source_info.get() == other.source_info.get();
  }
};
class Reportee {
public:
  virtual ~Reportee() = default;
  enum ReportKind {
    error,
    warn,
    diag,
  };
  using Report = std::tuple<Location, std::vector<std::string>, ReportKind,
                            std::source_location>;
 
  using iterator = std::vector<Report>::iterator;
  using const_iterator = std::vector<Report>::const_iterator;
 
  // Iterator methods
  iterator begin() { return reports.begin(); }
  iterator end() { return reports.end(); }
  const_iterator begin() const { return reports.begin(); }
  const_iterator end() const { return reports.end(); }
  const_iterator cbegin() const { return reports.cbegin(); }
  const_iterator cend() const { return reports.cend(); }
  [[noreturn]] virtual void abort(const std::string &msg = "<NO MESSAGE>") {
    sammine_util::abort(msg);
  }
  template <explicitly_bool_like T>
  void abort_on(const T &condition,
                const std::string &message = "<NO MESSAGE>") {
    if (static_cast<bool>(condition)) {
      this->abort(message);
    }
  }
 
  template <explicitly_bool_like T>
  void abort_if_not(const T &condition,
                    const std::string &message = "<NO MESSAGE>") {
    if (!static_cast<bool>(condition)) {
      this->abort(message);
    }
  }
  void add_error(Location loc, std::string msg,
                 std::source_location src = std::source_location::current()) {
    reports.push_back({loc, {std::move(msg)}, ReportKind::error, src});
    error_count++;
  }
  void add_error(Location loc, std::vector<std::string> msgs,
                 std::source_location src = std::source_location::current()) {
    reports.push_back({loc, std::move(msgs), ReportKind::error, src});
    error_count++;
  }
  void add_warn(Location loc, std::string msg,
                std::source_location src = std::source_location::current()) {
    reports.push_back({loc, {std::move(msg)}, ReportKind::warn, src});
    warn_count++;
  }
  void
  add_diagnostics(Location loc, std::string msg,
                  std::source_location src = std::source_location::current()) {
    reports.push_back({loc, {std::move(msg)}, ReportKind::diag, src});
    diag_count++;
  }
 
  [[nodiscard]] virtual bool has_errors() const { return error_count > 0; }
  [[nodiscard]] bool has_warn() const { return warn_count > 0; }
  [[nodiscard]] bool has_message() const { return !reports.empty(); }
 
  [[nodiscard]] bool has_diagnostics() const { return diag_count > 0; }
 
  [[nodiscard]] int64_t get_error_count() const { return error_count; }
 
  [[nodiscard]] int64_t get_warn_count() const { return warn_count; }
  [[nodiscard]] int64_t get_diagnostic_count() const { return diag_count; }
 
protected:
  std::vector<Report> reports;
  int64_t error_count = 0;
  int64_t warn_count = 0;
  int64_t diag_count = 0;
};
 
class Reporter {
public:
  using ReportKind = Reportee::ReportKind;
  using IndexPair = std::pair<int64_t, int64_t>;
  using DiagnosticData = std::vector<std::pair<std::int64_t, std::string_view>>;
 
  static DiagnosticData get_diagnostic_data(std::string_view str);
 
  inline static fmt::terminal_color LINE_COLOR =
      fmt::terminal_color::bright_magenta;
 
  static fmt::terminal_color get_color_from(ReportKind report_kind);
 
  template <typename... T>
  static void print_fmt(fmt::terminal_color ts,
                        fmt::format_string<T...> format_str, T &&...args) {
    if (stderr_is_tty())
      fmt::print(stderr, fg(ts), format_str, std::forward<T>(args)...);
    else
      fmt::print(stderr, format_str, std::forward<T>(args)...);
  }
  template <typename... T>
  static void print_fmt(fmt::color ts, fmt::format_string<T...> format_str,
                        T &&...args) {
    if (stderr_is_tty())
      fmt::print(stderr, fg(ts), format_str, std::forward<T>(args)...);
    else
      fmt::print(stderr, format_str, std::forward<T>(args)...);
  }
  template <typename... T>
  static void print_fmt(const ReportKind report_kind,
                        fmt::format_string<T...> format_str, T &&...args) {
    if (stderr_is_tty())
      fmt::print(stderr, fg(get_color_from(report_kind)), format_str,
                 std::forward<T>(args)...);
    else
      fmt::print(stderr, format_str, std::forward<T>(args)...);
  }
 
  static void print_data_singular_line(std::string_view msg, int64_t col_start,
                                       int64_t col_end);
 
private:
  inline static fmt::terminal_color MSG_COLOR = fmt::terminal_color::blue;
  std::string file_name;
  std::string input;
  std::vector<std::pair<std::int64_t, std::string_view>> diagnostic_data;
  int64_t context_radius;
  bool dev_mode = false;
 
  void report_single_msg(const Location &loc,
                         const std::vector<std::string> &format_strs,
                         const ReportKind report_kind,
                         std::source_location src = std::source_location::current()) const;
 
  void indicate_singular_line(ReportKind report_kind, int64_t col_start,
                              int64_t col_end) const;
 
  static void report_singular_line(ReportKind report_kind,
                                   const std::vector<std::string> &msgs,
                                   int64_t col_start, int64_t col_end);
 
public:
  void report(const Reportee &reports) const;
  void immediate_error(const std::string &str, Location l = Location(-1, -1),
                       std::source_location src = std::source_location::current()) {
    if (l.source_start <= 0 && l.source_end <= 0) {
      print_fmt(LINE_COLOR, "    |");
      print_fmt(fmt::terminal_color::blue, "In {}\n", file_name);
      report_singular_line(ReportKind::error, {str}, 0, 0);
 
    } else {
      report_single_msg(l, {str}, ReportKind::error, src);
    }
  }
  void immediate_diag(const std::string &str, Location l = Location(-1, -1),
                      std::source_location src = std::source_location::current()) {
    if (l.source_start <= 0 && l.source_end <= 0) {
      print_fmt(LINE_COLOR, "    |");
      print_fmt(fmt::terminal_color::blue, "In {}\n", file_name);
      report_singular_line(ReportKind::diag, {str}, 0, 0);
    } else {
      report_single_msg(l, {str}, ReportKind::diag, src);
    }
  }
  void immediate_warn(const std::string &str, Location l = Location(-1, -1),
                      std::source_location src = std::source_location::current()) {
    if (l.source_start <= 0 && l.source_end <= 0) {
      print_fmt(LINE_COLOR, "    |");
      print_fmt(fmt::terminal_color::blue, "In {}\n", file_name);
      report_singular_line(ReportKind::warn, {str}, 0, 0);
    } else {
      report_single_msg(l, {str}, ReportKind::warn, src);
    }
  }
  Reporter() {}
  Reporter(std::string file_name, std::string input, int64_t context_radius,
           bool dev_mode = false)
      : file_name(file_name), input(input),
        diagnostic_data(get_diagnostic_data(this->input)),
        context_radius(context_radius), dev_mode(dev_mode) {}
};
} // namespace sammine_util