diagnostic.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/graph/configuration_failure.h>
#include <neograph/json.h>
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
 
namespace neograph::program {
 
enum class CompilePhase {
    Source,
    Schema,
    Normalize,
    Resolve,
    TypeCheck,
    CoreParse,
    CoreValidate,
    Seal,
};
 
enum class DiagnosticSeverity { Error, Warning, Note };
 
struct SourceSpan {
    std::uint64_t byte_begin   = 0;
    std::uint64_t byte_end     = 0;
    std::uint32_t line_begin   = 1;
    std::uint32_t column_begin = 1;
    std::uint32_t line_end     = 1;
    std::uint32_t column_end   = 1;
 
    bool operator==(const SourceSpan&) const = default;
};
 
struct SourceCoordinate {
    std::string               source_id;
    std::string               json_pointer;
    std::optional<SourceSpan> span;
 
    bool operator==(const SourceCoordinate&) const = default;
};
 
enum class SuggestionApplicability {
    Machine,      
    Maybe,        
    Placeholder,  
};
 
struct SuggestionEdit {
    std::string op;
    std::string path;
    std::string from;
    json        value;
};
 
struct DiagnosticSuggestion {
    std::string                 message;
    std::vector<SuggestionEdit> edits;
    SuggestionApplicability     applicability = SuggestionApplicability::Maybe;
};
 
struct LabelledCoordinate {
    std::string      label;
    SourceCoordinate coordinate;
};
 
struct DiagnosticHelp {
    std::string                       doc;
    std::vector<LabelledCoordinate>   related;
    std::vector<DiagnosticSuggestion> suggestions;
    std::vector<std::string> candidates;
};
 
struct Diagnostic {
    CompilePhase                  phase = CompilePhase::Source;
    std::string                   code;
    DiagnosticSeverity            severity = DiagnosticSeverity::Error;
    SourceCoordinate              primary;
    std::string                   message;
    json                          witness;
    std::vector<SourceCoordinate> related;
    std::optional<DiagnosticHelp> help;
};
 
inline constexpr std::string_view DIAGNOSTICS_TRUNCATED_CODE = "P_DIAGNOSTICS_TRUNCATED";
inline constexpr std::size_t MAX_RETURNED_DIAGNOSTICS = 20;
 
NEOGRAPH_PROGRAM_API std::string_view to_string(CompilePhase phase) noexcept;
NEOGRAPH_PROGRAM_API std::string_view   to_string(DiagnosticSeverity severity) noexcept;
NEOGRAPH_PROGRAM_API std::string_view   to_string(SuggestionApplicability applicability) noexcept;
NEOGRAPH_PROGRAM_API CompilePhase       compile_phase_from_string(std::string_view value);
NEOGRAPH_PROGRAM_API DiagnosticSeverity diagnostic_severity_from_string(std::string_view value);
NEOGRAPH_PROGRAM_API SuggestionApplicability
suggestion_applicability_from_string(std::string_view value);
 
NEOGRAPH_PROGRAM_API std::string diagnostic_doc_link(std::string_view code);
 
NEOGRAPH_PROGRAM_API std::size_t diagnostic_name_distance(std::string_view left,
                                                          std::string_view right,
                                                          std::size_t      limit = 2);
 
NEOGRAPH_PROGRAM_API std::vector<std::string> diagnostic_name_candidates(
    std::string_view unknown, const std::vector<std::string>& declared);
 
NEOGRAPH_PROGRAM_API Diagnostic sealed_diagnostic(Diagnostic diagnostic);
 
NEOGRAPH_PROGRAM_API void to_json(json& value, const SourceSpan& span);
NEOGRAPH_PROGRAM_API void from_json(const json& value, SourceSpan& span);
NEOGRAPH_PROGRAM_API void to_json(json& value, const SourceCoordinate& coordinate);
NEOGRAPH_PROGRAM_API void from_json(const json& value, SourceCoordinate& coordinate);
NEOGRAPH_PROGRAM_API void to_json(json& value, const DiagnosticHelp& help);
NEOGRAPH_PROGRAM_API void from_json(const json& value, DiagnosticHelp& help);
NEOGRAPH_PROGRAM_API void to_json(json& value, const Diagnostic& diagnostic);
NEOGRAPH_PROGRAM_API void from_json(const json& value, Diagnostic& diagnostic);
 
class NEOGRAPH_PROGRAM_API ProgramDiagnosticError : public std::runtime_error,
                                                    public graph::ConfigurationFailure {
public:
    explicit ProgramDiagnosticError(Diagnostic diagnostic);
    const Diagnostic& diagnostic() const noexcept;
 
private:
    Diagnostic diagnostic_;
};
 
}  // namespace neograph::program