15214772429

Committed 23 May 2025 04:19PM UTC coverage: 86.895% (+0.2%) from 86.726%

Build # 15214772429

Build Type

push

github

Committed by

SuperFola

Commit Message

feat(compiler, vm): adding new AT_SYM_SYM and AT_SYM_INDEX_SYM_INDEX super instructions to get elements from list in a single instruction

Run Details

40 of 44 new or added lines in 2 files covered. (90.91%)

178 existing lines in 8 files now uncovered.

7095 of 8165 relevant lines covered (86.9%)

86688.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

65.55

/src/arkreactor/Exceptions.cpp

#include <Ark/Exceptions.hpp>

#include <cassert>
#include <sstream>
#include <algorithm>
#include <fmt/core.h>
#include <fmt/color.h>
#include <fmt/ostream.h>

#include <Ark/Constants.hpp>
#include <Ark/Utils.hpp>
#include <Ark/Files.hpp>
#include <Ark/Literals.hpp>
#include <Ark/Compiler/AST/Node.hpp>

namespace Ark::Diagnostics
{
    struct LineColorContextCounts
    {
        int open_parentheses = 0;
        int open_square_braces = 0;
        int open_curly_braces = 0;
    };

    inline bool isPairableChar(const char c)
    {
        return c == '(' || c == ')' || c == '[' || c == ']' || c == '{' || c == '}';
    }

    void colorizeLine(const std::string& line, LineColorContextCounts& line_color_context_counts, std::ostream& ss)
    {
        // clang-format off
        constexpr std::array pairing_color {
            fmt::color::light_blue,
            fmt::color::light_green,
            fmt::color::light_salmon,
            fmt::color::light_yellow,
            fmt::color::light_cyan,
            fmt::color::light_coral
        };
        // clang-format on
        constexpr std::size_t pairing_color_size = pairing_color.size();

        for (const char& c : line)
        {
            if (isPairableChar(c))
            {
                std::size_t pairing_color_index = 0;

                switch (c)
                {
                    case '(':
                        pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_parentheses)) % pairing_color_size;
                        line_color_context_counts.open_parentheses++;
                        break;
                    case ')':
                        line_color_context_counts.open_parentheses--;
                        pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_parentheses)) % pairing_color_size;
                        break;
                    case '[':
                        pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_square_braces)) % pairing_color_size;
                        line_color_context_counts.open_square_braces++;
                        break;
                    case ']':
                        line_color_context_counts.open_square_braces--;
                        pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_square_braces)) % pairing_color_size;
                        break;
                    case '{':
                        pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_curly_braces)) % pairing_color_size;
                        line_color_context_counts.open_curly_braces++;
                        break;
                    case '}':
                        line_color_context_counts.open_curly_braces--;
                        pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_curly_braces)) % pairing_color_size;
                        break;
                    default:
                        break;
                }

                fmt::print(ss, "{}", fmt::styled(c, fmt::fg(pairing_color[pairing_color_index])));
            }
            else
                fmt::print(ss, "{}", c);
        }
    }

    void makeContext(
        std::ostream& os,
        const std::string& filename,
        const std::optional<std::string>& expr,
        const std::size_t sym_size,
        const std::size_t target_line,
        const std::size_t col_start,
        const std::optional<CodeErrorContext>& maybe_context,  // can not be populated at runtime, only compile time
        const bool whole_line,
        const bool colorize)
    {
        assert(!(maybe_context && whole_line) && "Can not create error context when a context is given AND the whole line has to be underlined");

        using namespace Ark::literals;

        auto show_file_location = [&] {
            if (filename != ARK_NO_NAME_FILE)
                fmt::print(os, "In file {}:{}\n", filename, target_line + 1);
            if (expr)
                fmt::print(os, "At {} @ {}:{}\n", expr.value(), target_line + 1, col_start);
        };

        auto compute_start_end_window = [](const std::size_t center_of_window, const std::size_t line_count) {
            std::size_t start = center_of_window >= 3 ? center_of_window - 3 : 0;
            std::size_t end = center_of_window + 3 <= line_count ? center_of_window + 3 : line_count;
            return std::make_pair(start, end);
        };

        auto print_line = [&os, colorize](const std::size_t i, const std::vector<std::string>& lines, LineColorContextCounts& color_context) {
            // show current line with its number
            fmt::print(os, "{: >5} |{}", i + 1, !lines[i].empty() ? " " : "");
            if (colorize)
                colorizeLine(lines[i], color_context, os);
            else
                fmt::print(os, "{}", lines[i]);
            fmt::print(os, "\n");
        };

        const std::string line_no_num = "      |";

        auto print_context_hint = [&os, &maybe_context, &line_no_num, colorize]() mutable {
            if (!maybe_context)
                return;

            fmt::print(os, "{}", line_no_num);
            fmt::print(
                os,
                "{: <{}}{}\n",
                // padding os spaces
                " ",
                std::max(1_z, maybe_context->col),  // fixing padding when the error is on the first character
                // underline the parent of the error in red
                fmt::styled(
                    maybe_context->is_macro_expansion ? "^ macro expansion started here" : "^ expression started here",
                    colorize ? fmt::fg(fmt::color::red) : fmt::text_style()));
        };

        const std::string code = filename == ARK_NO_NAME_FILE ? "" : Utils::readFile(filename);
        const std::vector<std::string> lines = Utils::splitString(code, '\n');
        if (target_line >= lines.size() || code.empty())
        {
            // show the "in file..." before early return
            show_file_location();
            return;
        }

        auto [first_line, last_line] = compute_start_end_window(target_line, lines.size());
        // number of characters that are on more lines below
        std::size_t overflow = (col_start + sym_size < lines[target_line].size()) ? 0 : col_start + sym_size - lines[target_line].size();

        const bool ctx_same_file = maybe_context && maybe_context->filename == filename;
        const bool ctx_in_window = ctx_same_file && maybe_context &&
            maybe_context->line >= first_line &&
            maybe_context->line < last_line;

        std::size_t start_line_skipping_at = 0;
        std::size_t stop_line_skipping_at = first_line;
        if (ctx_same_file && !ctx_in_window)
        {
            // showing the context will require an ellipsis, to avoid showing too many lines in the error message
            if (maybe_context->line + 3 < first_line)
                start_line_skipping_at = maybe_context->line + 3;
            else
                stop_line_skipping_at = start_line_skipping_at;

            // due to how context works, if it points to the same file,
            // we are guaranteed it will be before our error
            first_line = maybe_context->line >= 3 ? maybe_context->line - 3 : 0;
        }
        else if (maybe_context && !ctx_same_file && !maybe_context->filename.empty())
        {
            // show the location of the parent of our error first
            fmt::print(os, "Error originated from file {}:{}\n", maybe_context->filename, maybe_context->line + 1);

            const std::vector<std::string> ctx_source_lines = Utils::splitString(Utils::readFile(maybe_context->filename), '\n');
            auto [ctx_first_line, ctx_last_line] = compute_start_end_window(maybe_context->line, ctx_source_lines.size());
            LineColorContextCounts line_color_context_counts;

            for (auto i = ctx_first_line; i < ctx_last_line; ++i)
            {
                print_line(i, ctx_source_lines, line_color_context_counts);
                if (i == maybe_context->line)
                    print_context_hint();
            }

            fmt::print(os, "\n");
        }

        show_file_location();
        LineColorContextCounts line_color_context_counts;

        for (auto i = first_line; i < last_line; ++i)
        {
            if (i >= start_line_skipping_at && i < stop_line_skipping_at)
                continue;
            print_line(i, lines, line_color_context_counts);

            // if the error context is in the current file, point to it as the parent of our error
            if (maybe_context && i == maybe_context->line && i != target_line)
                print_context_hint();

            // if the next line number wants us to skip line, and start != stop (meaning they got adjusted),
            // display an ellipsis
            if (i + 1 == start_line_skipping_at && i + 1 != stop_line_skipping_at)
                fmt::print(os, "  ... |\n");

            // show where the error occurred (do not mark empty lines as being part of the error when we have overflow)
            if (i == target_line || (i > target_line && overflow > 0 && !lines[i].empty()))
            {
                fmt::print(os, "{}", line_no_num);

                if (!whole_line)
                {
                    // if we have an overflow then we start at the beginning of the line
                    const std::size_t curr_col_start = (overflow == 0) ? col_start : 0;
                    // if we have an overflow, it is used as the end of the line
                    const std::size_t col_end = (i == target_line) ? std::min<std::size_t>(col_start + sym_size, lines[target_line].size())
                                                                   : std::min<std::size_t>(overflow, lines[i].size());
                    // update the overflow to avoid going here again if not needed
                    overflow = (overflow > lines[i].size()) ? overflow - lines[i].size() : 0;

                    // show the error where it's at, using the normal process, if there is no context OR if the context line is different from the error line
                    if (!maybe_context || maybe_context->line != target_line)
                        fmt::print(
                            os,
                            "{: <{}}{:~<{}}\n",
                            // padding of spaces
                            " ",
                            std::max(1_z, curr_col_start),  // fixing padding when the error is on the first character
                            // underline the error in red
                            fmt::styled("^", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()),
                            col_end - curr_col_start);
                    else if (i == target_line)  // maybe_context has a value, i == target_line to avoid having to deal with overflow
                    {
                        const auto padding_size = std::max(1_z, maybe_context->col);

                        fmt::print(
                            os,
                            "{: <{}}{}{}{}\n",
                            // padding of spaces
                            " ",
                            padding_size,
                            // indicate where the parent is, with color
                            fmt::styled("│", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()),
                            // yet another padding of spaces between the parent and error column (if need be)
                            // -2 to account for the │ and then └
                            (col_start - maybe_context->col <= 2) ? "" : fmt::format("{: <{}}", " ", col_start - maybe_context->col - 2),
                            // underline the error in red
                            fmt::styled("└─ error", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()));
                        // new line, some spacing between the error and the parent
                        fmt::print(os, "{}{: <{}}{}\n", line_no_num, " ", padding_size, fmt::styled("│", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()));
                        // new line, now show the "expression started here for the source"
                        fmt::print(
                            os,
                            "{}{: <{}}{}\n",
                            line_no_num,
                            // padding of spaces
                            " ",
                            padding_size,
                            fmt::styled(
                                maybe_context->is_macro_expansion ? "└─ macro expansion started here" : "└─ expression started here",
                                colorize ? fmt::fg(fmt::color::red) : fmt::text_style()));
                    }
                }
                else
                {
                    // first non-whitespace character of the line
                    // +1 for the leading whitespace after `    |` before the code
                    const std::size_t curr_col_start = lines[i].find_first_not_of(" \t\v") + 1;

                    // highlight the current line but skip any leading whitespace
                    fmt::print(
                        os,
                        "{: <{}}{:~<{}}\n",
                        // padding of spaces
                        " ",
                        curr_col_start,
                        // underline the whole line in red
                        fmt::styled("^", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()),
                        lines[target_line].size() - curr_col_start);
                }
            }
        }
    }

    void helper(std::ostream& os, const std::string& message, const bool colorize,
                const std::string& filename,
                const std::optional<std::string>& expr, const std::size_t sym_size,
                const std::size_t line, const std::size_t column,
                const std::optional<CodeErrorContext>& maybe_context = std::nullopt)
    {
        makeContext(os, filename, expr, sym_size, line, column, maybe_context, /* whole_line= */ false, colorize);

        const auto message_lines = Utils::splitString(message, '\n');
        for (const auto& text : message_lines)
            fmt::print(os, "        {}\n", text);
    }

    std::string makeContextWithNode(const std::string& message, const internal::Node& node)
    {
        std::stringstream ss;

        std::size_t size = 3;
        if (node.isStringLike())
            size = node.string().size();

        helper(
            ss,
            message,
            true,
            node.filename(),
            node.repr(),
            size,
            node.line(),
            node.col());

        return ss.str();
    }

    void generate(const CodeError& e, std::ostream& os, bool colorize)
    {
#ifdef ARK_BUILD_EXE
        if (const char* nocolor = std::getenv("NOCOLOR"); nocolor != nullptr)
            colorize = false;
#endif

        std::string escaped_symbol;
        if (e.context.symbol.has_value())
        {
            switch (e.context.symbol.value().codepoint())
            {
                case '\n': escaped_symbol = "'\\n'"; break;
                case '\r': escaped_symbol = "'\\r'"; break;
                case '\t': escaped_symbol = "'\\t'"; break;
                case '\v': escaped_symbol = "'\\v'"; break;
                case '\0': escaped_symbol = "EOF"; break;
                case ' ': escaped_symbol = "' '"; break;
                default:
                    escaped_symbol = e.context.symbol.value().c_str();
            }
        }
        else
            escaped_symbol = e.context.expr;

        helper(
            os,
            e.what(),
            colorize,
            e.context.filename,
            escaped_symbol,
            e.context.expr.size(),
            e.context.line,
            e.context.col,
            e.additional_context);
    }
}

1	#include <Ark/Exceptions.hpp>
2
3	#include <cassert>
4	#include <sstream>
5	#include <algorithm>
6	#include <fmt/core.h>
7	#include <fmt/color.h>
8	#include <fmt/ostream.h>
9
10	#include <Ark/Constants.hpp>
11	#include <Ark/Utils.hpp>
12	#include <Ark/Files.hpp>
13	#include <Ark/Literals.hpp>
14	#include <Ark/Compiler/AST/Node.hpp>
15
16	namespace Ark::Diagnostics
17	{
18	struct LineColorContextCounts	219✔
19	{
20	int open_parentheses = 0;	219✔
21	int open_square_braces = 0;	219✔
22	int open_curly_braces = 0;	219✔
23	};
24
25	inline bool isPairableChar(const char c)	×
26	{	×
27	return c == '(' \|\| c == ')' \|\| c == '[' \|\| c == ']' \|\| c == '{' \|\| c == '}';	×
28	}
29
30	void colorizeLine(const std::string& line, LineColorContextCounts& line_color_context_counts, std::ostream& ss)	×
31	{	×
32	// clang-format off
33	constexpr std::array pairing_color {	×
34	fmt::color::light_blue,
35	fmt::color::light_green,
36	fmt::color::light_salmon,
37	fmt::color::light_yellow,
38	fmt::color::light_cyan,
39	fmt::color::light_coral
40	};
41	// clang-format on
42	constexpr std::size_t pairing_color_size = pairing_color.size();	×
43
44	for (const char& c : line)	×
45	{
46	if (isPairableChar(c))	×
47	{
48	std::size_t pairing_color_index = 0;	×
49
50	switch (c)	×
51	{	×
52	case '(':
53	pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_parentheses)) % pairing_color_size;	×
54	line_color_context_counts.open_parentheses++;	×
55	break;	×
56	case ')':
57	line_color_context_counts.open_parentheses--;	×
58	pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_parentheses)) % pairing_color_size;	×
59	break;	×
60	case '[':
61	pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_square_braces)) % pairing_color_size;	×
62	line_color_context_counts.open_square_braces++;	×
63	break;	×
64	case ']':
65	line_color_context_counts.open_square_braces--;	×
66	pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_square_braces)) % pairing_color_size;	×
67	break;	×
68	case '{':
69	pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_curly_braces)) % pairing_color_size;	×
70	line_color_context_counts.open_curly_braces++;	×
71	break;	×
72	case '}':
73	line_color_context_counts.open_curly_braces--;	×
74	pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_curly_braces)) % pairing_color_size;	×
75	break;	×
76	default:
77	break;	×
78	}	×
79
80	fmt::print(ss, "{}", fmt::styled(c, fmt::fg(pairing_color[pairing_color_index])));	×
81	}	×
82	else
83	fmt::print(ss, "{}", c);	×
84	}	×
85	}	×
86
87	void makeContext(	220✔
88	std::ostream& os,
89	const std::string& filename,
90	const std::optional<std::string>& expr,
91	const std::size_t sym_size,
92	const std::size_t target_line,
93	const std::size_t col_start,
94	const std::optional<CodeErrorContext>& maybe_context, // can not be populated at runtime, only compile time
95	const bool whole_line,
96	const bool colorize)
97	{	220✔
98	assert(!(maybe_context && whole_line) && "Can not create error context when a context is given AND the whole line has to be underlined");	220✔
99
100	using namespace Ark::literals;
101
102	auto show_file_location = [&] {	440✔
103	if (filename != ARK_NO_NAME_FILE)	220✔
104	fmt::print(os, "In file {}:{}\n", filename, target_line + 1);	220✔
105	if (expr)	220✔
106	fmt::print(os, "At {} @ {}:{}\n", expr.value(), target_line + 1, col_start);	118✔
107	};	220✔
108
109	auto compute_start_end_window = [](const std::size_t center_of_window, const std::size_t line_count) {	439✔
110	std::size_t start = center_of_window >= 3 ? center_of_window - 3 : 0;	219✔
111	std::size_t end = center_of_window + 3 <= line_count ? center_of_window + 3 : line_count;	219✔
112	return std::make_pair(start, end);	219✔
113	};	219✔
114
115	auto print_line = [&os, colorize](const std::size_t i, const std::vector<std::string>& lines, LineColorContextCounts& color_context) {	770✔
116	// show current line with its number
117	fmt::print(os, "{: >5} \|{}", i + 1, !lines[i].empty() ? " " : "");	550✔
118	if (colorize)	550✔
119	colorizeLine(lines[i], color_context, os);	×
120	else
121	fmt::print(os, "{}", lines[i]);	550✔
122	fmt::print(os, "\n");	550✔
123	};	550✔
124
125	const std::string line_no_num = " \|";	220✔
126
127	auto print_context_hint = [&os, &maybe_context, &line_no_num, colorize]() mutable {	229✔
128	if (!maybe_context)	9✔
129	return;	×
130
131	fmt::print(os, "{}", line_no_num);	9✔
132	fmt::print(	27✔
133	os,	9✔
134	"{: <{}}{}\n",	9✔
135	// padding os spaces
136	" ",
137	std::max(1_z, maybe_context->col), // fixing padding when the error is on the first character	9✔
138	// underline the parent of the error in red
139	fmt::styled(	18✔
140	maybe_context->is_macro_expansion ? "^ macro expansion started here" : "^ expression started here",	9✔
141	colorize ? fmt::fg(fmt::color::red) : fmt::text_style()));	9✔
142	};	9✔
143
144	const std::string code = filename == ARK_NO_NAME_FILE ? "" : Utils::readFile(filename);	220✔
145	const std::vector<std::string> lines = Utils::splitString(code, '\n');	220✔
146	if (target_line >= lines.size() \|\| code.empty())	220✔
147	{
148	// show the "in file..." before early return
149	show_file_location();	1✔
150	return;	1✔
151	}
152
153	auto [first_line, last_line] = compute_start_end_window(target_line, lines.size());	1,248✔
154	// number of characters that are on more lines below
155	std::size_t overflow = (col_start + sym_size < lines[target_line].size()) ? 0 : col_start + sym_size - lines[target_line].size();	219✔
156
157	const bool ctx_same_file = maybe_context && maybe_context->filename == filename;	219✔
158	const bool ctx_in_window = ctx_same_file && maybe_context &&	233✔
159	maybe_context->line >= first_line &&	25✔
160	maybe_context->line < last_line;	11✔
161
162	std::size_t start_line_skipping_at = 0;	219✔
163	std::size_t stop_line_skipping_at = first_line;	438✔
164	if (ctx_same_file && !ctx_in_window)	219✔
165	{
166	// showing the context will require an ellipsis, to avoid showing too many lines in the error message
167	if (maybe_context->line + 3 < first_line)	3✔
168	start_line_skipping_at = maybe_context->line + 3;	3✔
169	else
170	stop_line_skipping_at = start_line_skipping_at;	×
171
172	// due to how context works, if it points to the same file,
173	// we are guaranteed it will be before our error
174	first_line = maybe_context->line >= 3 ? maybe_context->line - 3 : 0;	3✔
175	}	3✔
176	else if (maybe_context && !ctx_same_file && !maybe_context->filename.empty())	216✔
177	{
178	// show the location of the parent of our error first
179	fmt::print(os, "Error originated from file {}:{}\n", maybe_context->filename, maybe_context->line + 1);	×
180
181	const std::vector<std::string> ctx_source_lines = Utils::splitString(Utils::readFile(maybe_context->filename), '\n');	×
182	auto [ctx_first_line, ctx_last_line] = compute_start_end_window(maybe_context->line, ctx_source_lines.size());	×
183	LineColorContextCounts line_color_context_counts;	×
184
185	for (auto i = ctx_first_line; i < ctx_last_line; ++i)	×
186	{
187	print_line(i, ctx_source_lines, line_color_context_counts);	×
188	if (i == maybe_context->line)	×
189	print_context_hint();	×
190	}	×
191
192	fmt::print(os, "\n");	×
193	}	×
194
195	show_file_location();	219✔
196	LineColorContextCounts line_color_context_counts;	219✔
197
198	for (auto i = first_line; i < last_line; ++i)	1,001✔
199	{
200	if (i >= start_line_skipping_at && i < stop_line_skipping_at)	563✔
201	continue;	13✔
202	print_line(i, lines, line_color_context_counts);	550✔
203
204	// if the error context is in the current file, point to it as the parent of our error
205	if (maybe_context && i == maybe_context->line && i != target_line)	550✔
206	print_context_hint();	9✔
207
208	// if the next line number wants us to skip line, and start != stop (meaning they got adjusted),
209	// display an ellipsis
210	if (i + 1 == start_line_skipping_at && i + 1 != stop_line_skipping_at)	550✔
211	fmt::print(os, " ... \|\n");	3✔
212
213	// show where the error occurred (do not mark empty lines as being part of the error when we have overflow)
214	if (i == target_line \|\| (i > target_line && overflow > 0 && !lines[i].empty()))	550✔
215	{
216	fmt::print(os, "{}", line_no_num);	221✔
217
218	if (!whole_line)	221✔
219	{
220	// if we have an overflow then we start at the beginning of the line
221	const std::size_t curr_col_start = (overflow == 0) ? col_start : 0;	119✔
222	// if we have an overflow, it is used as the end of the line
223	const std::size_t col_end = (i == target_line) ? std::min<std::size_t>(col_start + sym_size, lines[target_line].size())	121✔
224	: std::min<std::size_t>(overflow, lines[i].size());	2✔
225	// update the overflow to avoid going here again if not needed
226	overflow = (overflow > lines[i].size()) ? overflow - lines[i].size() : 0;	119✔
227
228	// show the error where it's at, using the normal process, if there is no context OR if the context line is different from the error line
229	if (!maybe_context \|\| maybe_context->line != target_line)	119✔
230	fmt::print(	330✔
231	os,	110✔
232	"{: <{}}{:~<{}}\n",	110✔
233	// padding of spaces
234	" ",
235	std::max(1_z, curr_col_start), // fixing padding when the error is on the first character	110✔
236	// underline the error in red
237	fmt::styled("^", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()),	110✔
238	col_end - curr_col_start);	110✔
239	else if (i == target_line) // maybe_context has a value, i == target_line to avoid having to deal with overflow	9✔
240	{
241	const auto padding_size = std::max(1_z, maybe_context->col);	9✔
242
243	fmt::print(	18✔
244	os,	9✔
245	"{: <{}}{}{}{}\n",	9✔
246	// padding of spaces
247	" ",
248	padding_size,
249	// indicate where the parent is, with color
250	fmt::styled("│", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()),	9✔
251	// yet another padding of spaces between the parent and error column (if need be)
252	// -2 to account for the │ and then └
253	(col_start - maybe_context->col <= 2) ? "" : fmt::format("{: <{}}", " ", col_start - maybe_context->col - 2),	9✔
254	// underline the error in red
255	fmt::styled("└─ error", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()));	9✔
256	// new line, some spacing between the error and the parent
257	fmt::print(os, "{}{: <{}}{}\n", line_no_num, " ", padding_size, fmt::styled("│", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()));	9✔
258	// new line, now show the "expression started here for the source"
259	fmt::print(	18✔
260	os,	9✔
261	"{}{: <{}}{}\n",	9✔
262	line_no_num,
263	// padding of spaces
264	" ",
265	padding_size,
266	fmt::styled(	18✔
267	maybe_context->is_macro_expansion ? "└─ macro expansion started here" : "└─ expression started here",	9✔
268	colorize ? fmt::fg(fmt::color::red) : fmt::text_style()));	9✔
269	}	9✔
270	}	119✔
271	else
272	{
273	// first non-whitespace character of the line
274	// +1 for the leading whitespace after ` \|` before the code
275	const std::size_t curr_col_start = lines[i].find_first_not_of(" \t\v") + 1;	102✔
276
277	// highlight the current line but skip any leading whitespace
278	fmt::print(	204✔
279	os,	102✔
280	"{: <{}}{:~<{}}\n",	102✔
281	// padding of spaces
282	" ",
283	curr_col_start,
284	// underline the whole line in red
285	fmt::styled("^", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()),	102✔
286	lines[target_line].size() - curr_col_start);	102✔
287	}	102✔
288	}	221✔
289	}	550✔
290	}	220✔
291
292	void helper(std::ostream& os, const std::string& message, const bool colorize,	118✔
293	const std::string& filename,
294	const std::optional<std::string>& expr, const std::size_t sym_size,
295	const std::size_t line, const std::size_t column,
296	const std::optional<CodeErrorContext>& maybe_context = std::nullopt)
297	{	118✔
298	makeContext(os, filename, expr, sym_size, line, column, maybe_context, /* whole_line= */ false, colorize);	118✔
299
300	const auto message_lines = Utils::splitString(message, '\n');	118✔
301	for (const auto& text : message_lines)	236✔
302	fmt::print(os, " {}\n", text);	118✔
303	}	118✔
304
305	std::string makeContextWithNode(const std::string& message, const internal::Node& node)	×
306	{	×
307	std::stringstream ss;	×
308
309	std::size_t size = 3;	×
310	if (node.isStringLike())	×
311	size = node.string().size();	×
312
313	helper(	×
314	ss,	×
315	message,	×
316	true,
317	node.filename(),	×
318	node.repr(),	×
319	size,	×
320	node.line(),	×
321	node.col());	×
322
323	return ss.str();	×
324	}	×
325
326	void generate(const CodeError& e, std::ostream& os, bool colorize)	118✔
327	{	118✔
328	#ifdef ARK_BUILD_EXE
329	if (const char* nocolor = std::getenv("NOCOLOR"); nocolor != nullptr)	118✔
UNCOV 330	colorize = false;	×
331	#endif
332
333	std::string escaped_symbol;	118✔
334	if (e.context.symbol.has_value())	118✔
335	{
336	switch (e.context.symbol.value().codepoint())	43✔
337	{	×
338	case '\n': escaped_symbol = "'\\n'"; break;	×
UNCOV 339	case '\r': escaped_symbol = "'\\r'"; break;	×
UNCOV 340	case '\t': escaped_symbol = "'\\t'"; break;	×
341	case '\v': escaped_symbol = "'\\v'"; break;	11✔
342	case '\0': escaped_symbol = "EOF"; break;	13✔
343	case ' ': escaped_symbol = "' '"; break;	32✔
344	default:
345	escaped_symbol = e.context.symbol.value().c_str();	30✔
346	}	43✔
347	}	43✔
348	else
349	escaped_symbol = e.context.expr;	75✔
350
351	helper(	354✔
352	os,	118✔
353	e.what(),	118✔
354	colorize,	118✔
355	e.context.filename,	118✔
356	escaped_symbol,	118✔
357	e.context.expr.size(),	118✔
358	e.context.line,	118✔
359	e.context.col,	118✔
360	e.additional_context);	118✔
361	}	118✔
362	}

ArkScript-lang / Ark / 15214772429

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous