Formatter.cpp

Go to the documentation of this file.

#include <Ark/Constants.hpp>
#include <CLI/Formatter.hpp>
 
#include <fmt/core.h>
 
#include <Ark/Utils/Files.hpp>
#include <Ark/Error/Exceptions.hpp>
#include <Ark/Error/Diagnostics.hpp>
#include <Ark/Compiler/Common.hpp>
#include <Ark/Utils/Literals.hpp>
 
using namespace Ark;
using namespace Ark::internal;
using namespace Ark::literals;
 
Formatter::Formatter(const bool dry_run) :
    m_dry_run(dry_run), m_parser(/* debug= */ 0, ParserMode::Raw), m_updated(false), m_logger("formatter", 0)
{}
 
Formatter::Formatter(std::string filename, const bool dry_run) :
    m_filename(std::move(filename)), m_dry_run(dry_run), m_parser(/* debug= */ 0, ParserMode::Raw), m_updated(false), m_logger("formatter", 0)
{}
 
void Formatter::run()
{
    try
    {
        const std::string code = Utils::readFile(m_filename);
        m_parser.process(m_filename, code);
        processAst(m_parser.ast());
        warnIfCommentsWereRemoved(code, ARK_NO_NAME_FILE);
 
        m_updated = code != m_output;
    }
    catch (const CodeError& e)
    {
        Diagnostics::generate(e);
    }
}
 
void Formatter::runWithString(const std::string& code)
{
    try
    {
        m_parser.process(ARK_NO_NAME_FILE, code);
        processAst(m_parser.ast());
        warnIfCommentsWereRemoved(code, ARK_NO_NAME_FILE);
 
        m_updated = code != m_output;
    }
    catch (const CodeError& e)
    {
        Diagnostics::generate(e);
    }
}
 
const std::string& Formatter::output() const
{
    return m_output;
}
 
bool Formatter::codeModified() const
{
    return m_updated;
}
 
void Formatter::processAst(const Node& ast)
{
    // remove useless surrounding begin (generated by the parser)
    if (isBeginBlock(ast))
    {
        for (std::size_t i = 1, end = ast.constList().size(); i < end; ++i)
        {
            const Node node = ast.constList()[i];
            if (shouldAddNewLineBetweenNodes(ast, i) && !m_output.empty())
                m_output += "\n";
            m_output += format(node, 0, false) + "\n";
        }
    }
    else
        m_output = format(ast, 0, false);
 
    if (!m_dry_run)
    {
        std::ofstream stream(m_filename);
        stream << m_output;
    }
}
 
void Formatter::warnIfCommentsWereRemoved(const std::string& original_code, const std::string& filename)
{
    const std::size_t before_count = std::ranges::count(original_code, '#');
    const std::size_t after_count = std::ranges::count(m_output, '#');
 
    if (before_count != after_count)
    {
        m_logger.warn(
            "one or more comments from the original source code seem to have been {} by mistake while formatting {}",
            before_count > after_count ? "removed" : "duplicated",
            filename != ARK_NO_NAME_FILE ? filename : "file");
        m_logger.warn("Please fill an issue on GitHub: https://github.com/ArkScript-lang/Ark");
    }
}
 
bool Formatter::isListStartingWithKeyword(const Node& node, const Keyword keyword)
{
    return node.isListLike() && !node.constList().empty() && node.constList()[0].nodeType() == NodeType::Keyword && node.constList()[0].keyword() == keyword;
}
 
bool Formatter::isBeginBlock(const Node& node)
{
    return isListStartingWithKeyword(node, Keyword::Begin);
}
 
bool Formatter::isFuncDef(const Node& node)
{
    return isListStartingWithKeyword(node, Keyword::Fun);
}
 
bool Formatter::isFuncCall(const Node& node)
{
    return node.isListLike() && !node.constList().empty() && node.constList()[0].nodeType() == NodeType::Symbol;
}
 
std::size_t Formatter::lineOfLastNodeIn(const Node& node)
{
    if (node.isListLike() && !node.constList().empty())
    {
        const std::size_t child_line = lineOfLastNodeIn(node.constList().back());
        if (child_line < node.position().start.line)
            return node.position().start.line;
        return child_line;
    }
    return node.position().start.line;
}
 
bool Formatter::isLongLine(const Node& node)
{
    const std::string formatted = format(node, 0, false);
    const std::size_t max_len =
        std::ranges::max(
            Utils::splitString(formatted, '\n'),
            [](const std::string& lhs, const std::string& rhs) {
                return lhs.size() < rhs.size();
            })
            .size();
    const std::size_t newlines = std::ranges::count(formatted, '\n');
 
    // split on multiple lines if we have a very long node,
    // or if we added many line breaks while doing dumb formatting
    return max_len >= FormatterConfig::LongLineLength || (newlines > 0 && node.isListLike() && newlines + 1 >= node.constList().size());
}
 
bool Formatter::shouldSplitOnNewline(const Node& node, const bool on_multiple_lines)
{
    if (node.comment().empty() && isBeginBlock(node))
        return false;
    // If we have a function call that isn't on multiple lines,
    // or a function call that is special (eg a switch, dict or list),
    // no need to add a new line before the node.
    // e.g. this is on multiple lines, but we have a special call:
    // (let a (switch day
    //   1 nil
    //   2 true))
    if (node.comment().empty() && isFuncCall(node) && (!on_multiple_lines || callKind(node) != CallKind::Nothing))
        return false;
    return on_multiple_lines ||
        isLongLine(node) ||
        (node.isListLike() && node.constList().size() > 1) ||
        !node.comment().empty();
}
 
bool Formatter::shouldAddNewLineBetweenNodes(const Node& node, const std::size_t at)
{
    if (at <= 1)
        return false;
 
    const auto& list = node.constList();
    const std::size_t previous_line = lineOfLastNodeIn(list[at - 1]);
 
    const auto& child = list[at];
 
    // If we have a node before the current one,
    // and the line count between the two nodes is more than 1,
    // maybe we should add a new line to preserve user spacing.
    // However, if the current node has a comment, do not add a new line, this is causing the spacing.
    if (child.position().start.line - previous_line > 1 && child.comment().empty())
        return true;
    // If we do have a comment but the spacing is more than 2,
    // then add a newline to preserve user spacing.
    if (child.position().start.line - previous_line > 2 && !child.comment().empty())
        return true;
    return false;
}
 
CallKind Formatter::callKind(const Node& node)
{
    if (!node.constList().empty() && node.constList().front().nodeType() == NodeType::Symbol)
    {
        const auto& sym = node.constList().front().string();
        if (sym == "list")
            return CallKind::List;
        if (sym == "dict")
            return CallKind::Dict;
        if (sym == "switch")
            return CallKind::Switch;
    }
 
    return CallKind::Nothing;
}
 
std::string Formatter::format(const Node& node, std::size_t indent, bool after_newline)
{
    std::string result;
    if (!node.comment().empty())
    {
        result += formatComment(node.comment(), indent);
        after_newline = true;
    }
    if (after_newline)
        result += prefix(indent);
 
    switch (node.nodeType())
    {
        case NodeType::Symbol:
            result += node.string();
            break;
        case NodeType::MutArg:
            result += fmt::format("(mut {})", node.string());
            break;
        case NodeType::RefArg:
            result += fmt::format("(ref {})", node.string());
            break;
        case NodeType::Capture:
            result += "&" + node.string();
            break;
        case NodeType::Keyword:
            result += std::string(keywords[static_cast<std::size_t>(node.keyword())]);
            break;
        case NodeType::String:
            result += fmt::format("{}\"{}\"", node.isRawString() ? "r" : "", node.string());
            break;
        case NodeType::Number:
            result += fmt::format("{}", node.number());
            break;
        case NodeType::List:
            result += formatBlock(node, indent, after_newline);
            break;
        case NodeType::Spread:
            result += fmt::format("...{}", node.string());
            break;
        case NodeType::Field:
        {
            std::string field = format(node.constList()[0], indent, false);
            for (std::size_t i = 1, end = node.constList().size(); i < end; ++i)
                field += "." + format(node.constList()[i], indent, false);
            result += field;
            break;
        }
        case NodeType::Macro:
            result += formatMacro(node, indent);
            break;
        // not handling Namespace nor Unused node types as those can not be generated by the parser
        case NodeType::Namespace:
            [[fallthrough]];
        case NodeType::Unused:
            break;
    }
 
    if (!node.commentAfter().empty())
        result += " " + formatComment(node.commentAfter(), /* indent= */ 0);
 
    return result;
}
 
std::string Formatter::formatComment(const std::string& comment, const std::size_t indent) const
{
    std::string result = prefix(indent);
    for (std::size_t i = 0, end = comment.size(); i < end; ++i)
    {
        result += comment[i];
        if (comment[i] == '\n' && i != end - 1)
            result += prefix(indent);
    }
 
    return result;
}
 
std::string Formatter::formatBlock(const Node& node, const std::size_t indent, const bool after_newline)
{
    if (node.constList().empty())
        return "()";
 
    const Node first = node.constList().front();
    if (first.nodeType() == NodeType::Keyword)
    {
        switch (first.keyword())
        {
            case Keyword::Fun:
                return formatFunction(node, indent);
            case Keyword::Let:
                [[fallthrough]];
            case Keyword::Mut:
                [[fallthrough]];
            case Keyword::Set:
                return formatVariable(node, indent);
            case Keyword::If:
                return formatCondition(node, indent);
            case Keyword::While:
                return formatLoop(node, indent);
            case Keyword::Begin:
                return formatBegin(node, indent, after_newline);
            case Keyword::Import:
                return formatImport(node, indent);
            case Keyword::Del:
                return formatDel(node, indent);
        }
        // HACK: should never reach, but the compiler insists that the function doesn't return in every code path
        return "";
    }
    return formatCall(node, indent);
}
 
std::string Formatter::formatFunction(const Node& node, const std::size_t indent)
{
    const Node args_node = node.constList()[1];
    const Node body_node = node.constList()[2];
 
    std::string formatted_args;
 
    if (!args_node.comment().empty())
    {
        formatted_args += "\n";
        formatted_args += formatComment(args_node.comment(), indent + 1);
        formatted_args += prefix(indent + 1);
    }
    else
        formatted_args += " ";
 
    if (args_node.isListLike())
    {
        bool comment_in_args = false;
        std::string args;
        const bool split = (isLongLine(args_node) || !args_node.comment().empty());
 
        for (std::size_t i = 0, end = args_node.constList().size(); i < end; ++i)
        {
            const Node arg_i = args_node.constList()[i];
            if (!arg_i.comment().empty())
                comment_in_args = true;
 
            args += format(arg_i, indent + ((comment_in_args || split) ? 1 : 0), i > 0 && (comment_in_args || split));
            if (i != end - 1)
                args += (comment_in_args || split) ? '\n' : ' ';
        }
 
        formatted_args += fmt::format("({}{})", (comment_in_args ? "\n" : ""), args);
    }
    else
        formatted_args += format(args_node, indent, false);
 
    const std::string same_line_f = format(body_node, indent + 1, false);
    if (!shouldSplitOnNewline(body_node, isOnMultipleLines(same_line_f)) && args_node.comment().empty())
        return fmt::format("(fun{} {})", formatted_args, same_line_f);
    return fmt::format("(fun{}\n{})", formatted_args, format(body_node, indent + 1, true));
}
 
std::string Formatter::formatVariable(const Node& node, const std::size_t indent)
{
    const auto keyword = std::string(keywords[static_cast<std::size_t>(node.constList()[0].keyword())]);
 
    const Node body_node = node.constList()[2];
    const std::string formatted_bind = format(node.constList()[1], indent, false);
 
    // we don't want to add another indentation level here, because it would result in a (let a (fun ()\n{indent+=4}...))
    const std::string same_line_f = format(body_node, indent, false);
    if (isFuncDef(body_node) || !shouldSplitOnNewline(body_node, isOnMultipleLines(same_line_f)))
        return fmt::format("({} {} {})", keyword, formatted_bind, same_line_f);
    return fmt::format("({} {}\n{})", keyword, formatted_bind, format(body_node, indent + 1, true));
}
 
std::string Formatter::formatCondition(const Node& node, const std::size_t indent, const bool is_macro)
{
    const Node cond_node = node.constList()[1];
    const Node then_node = node.constList()[2];
 
    bool cond_on_newline = false;
    const std::string formatted_cond = format(cond_node, indent + 1, false);
    if (formatted_cond.find('\n') != std::string::npos)
        cond_on_newline = true;
 
    std::string if_cond_formatted = fmt::format(
        "({}if{}{}",
        is_macro ? "$" : "",
        cond_on_newline ? "\n" : " ",
        cond_on_newline ? format(cond_node, indent + 1, true) : formatted_cond);
 
    // (if cond then)
    if (node.constList().size() == 3)
    {
        const std::string same_line_f = format(then_node, indent + 1, false);
        const bool split_then_newline = shouldSplitOnNewline(then_node, isOnMultipleLines(same_line_f)) || isBeginBlock(then_node);
        if (cond_on_newline || split_then_newline)
            return fmt::format("{}\n{})", if_cond_formatted, format(then_node, indent + 1, true));
        return fmt::format("{} {})", if_cond_formatted, same_line_f);
    }
    // (if cond then else)
    return fmt::format(
        "{}\n{}\n{}{})",
        if_cond_formatted,
        format(then_node, indent + 1, true),
        format(node.constList()[3], indent + 1, true),
        node.constList()[3].commentAfter().empty() ? "" : ("\n" + prefix(indent)));
}
 
std::string Formatter::formatLoop(const Node& node, const std::size_t indent)
{
    const Node cond_node = node.constList()[1];
    const Node body_node = node.constList()[2];
 
    const std::string formatted_cond = format(cond_node, indent + 1, false);
    const bool cond_on_newline = isOnMultipleLines(formatted_cond);
 
    if (cond_on_newline || shouldSplitOnNewline(body_node, cond_on_newline))
        return fmt::format(
            "(while{}{}\n{})",
            cond_on_newline ? "\n" : " ",
            cond_on_newline ? format(cond_node, indent + 1, true) : formatted_cond,
            format(body_node, indent + 1, true));
    return fmt::format(
        "(while {} {})",
        formatted_cond,
        format(body_node, indent + 1, false));
}
 
std::string Formatter::formatBegin(const Node& node, const std::size_t indent, const bool after_newline)
{
    // only the keyword begin is present
    if (node.constList().size() == 1)
        return "{}";
 
    // after a new line, we need to increment our indentation level
    // if the block is a top level one, we also need to increment indentation level
    const std::size_t inner_indentation = indent + (after_newline ? 1 : 0) + (indent == 0 ? 1 : 0);
 
    std::string result = "{\n";
    // skip begin keyword
    for (std::size_t i = 1, end = node.constList().size(); i < end; ++i)
    {
        const Node child = node.constList()[i];
        // we want to preserve the node grouping by the user, but remove useless duplicate new line
        // but that shouldn't apply to the first node of the block
        if (shouldAddNewLineBetweenNodes(node, i) && i > 1)
            result += "\n";
 
        result += format(child, inner_indentation, true);
        if (i != end - 1)
            result += "\n";
    }
 
    // if the last node has a comment, add a new line
    if (!node.constList().empty() && !node.constList().back().commentAfter().empty())
        result += "\n" + prefix(indent) + "}";
    else
        result += " }";
    return result;
}
 
std::string Formatter::formatImport(const Node& node, const std::size_t indent)
{
    const Node package_node = node.constList()[1];
    std::string package;
 
    if (!package_node.comment().empty())
        package += "\n" + formatComment(package_node.comment(), indent + 1) + prefix(indent + 1);
    else
        package += " ";
 
    for (std::size_t i = 0, end = package_node.constList().size(); i < end; ++i)
    {
        package += format(package_node.constList()[i], indent + 1, false);
        if (i != end - 1)
            package += ".";
    }
 
    const Node symbols = node.constList()[2];
    if (symbols.nodeType() == NodeType::Symbol && symbols.string() == "*")
        package += ":*";
    else  // symbols is a list
    {
        if (const auto& sym_list = symbols.constList(); !sym_list.empty())
        {
            const bool comment_after_last = !sym_list.back().commentAfter().empty();
 
            for (const auto& sym : sym_list)
            {
                if (sym.comment().empty())
                {
                    if (comment_after_last)
                        package += "\n" + prefix(indent + 1) + ":" + sym.string();
                    else
                        package += " :" + sym.string();
                }
                else
                    package += "\n" + formatComment(sym.comment(), indent + 1) + prefix(indent + 1) + ":" + sym.string();
            }
 
            if (comment_after_last)
            {
                package += " " + formatComment(sym_list.back().commentAfter(), /* indent= */ 0);
                package += "\n" + prefix(indent + 1);
            }
        }
    }
 
    return fmt::format("(import{})", package);
}
 
std::string Formatter::formatDel(const Node& node, const std::size_t indent)
{
    std::string formatted_sym = format(node.constList()[1], indent + 1, false);
    if (formatted_sym.find('\n') != std::string::npos)
        return fmt::format("(del\n{})", formatted_sym);
    return fmt::format("(del {})", formatted_sym);
}
 
std::string Formatter::formatCall(const Node& node, const std::size_t indent)
{
    const CallKind kind = callKind(node);
    bool is_multiline = false;
 
    std::vector<std::string> formatted_args;
    for (std::size_t i = 1, end = node.constList().size(); i < end; ++i)
    {
        formatted_args.push_back(format(node.constList()[i], indent, false));
        // if we have at least one argument taking multiple lines, split them all on their own line
        if (formatted_args.back().find('\n') != std::string::npos || !node.constList()[i].commentAfter().empty())
            is_multiline = true;
    }
 
    std::string result = kind == CallKind::List ? "[" : "(" + format(node.constList()[0], indent, false);
 
    // Split args on multiple lines even if, individually, they fit in the configured line length, if grouped together
    // on a single line they are too long
    const std::size_t args_line_length = std::accumulate(
        formatted_args.begin(),
        formatted_args.end(),
        result.size() + 1,  // +1 to count the closing paren/bracket
        [](const std::size_t acc, const std::string& val) {
            return acc + val.size() + 1_z;
        });
    if (args_line_length >= FormatterConfig::LongLineLength)
        is_multiline = true;
 
    for (std::size_t i = 0, end = formatted_args.size(); i < end; ++i)
    {
        const std::string& formatted_node = formatted_args[i];
        if (kind == CallKind::Dict)
        {
            if (i % 2 == 0 && formatted_args.size() > 2)  // one pair per line if we have at least 2 key-value pairs
                result += "\n" + format(node.constList()[i + 1], indent + 1, true);
            else
                result += " " + formatted_node;
        }
        else if (kind == CallKind::Switch)
        {
            // % 1 because we want `(switch var` to stay together, then the pairs on their own lines
            if (i % 2 == 1 && formatted_args.size() > 3)  // one pair per line, same as dict
                result += "\n" + format(node.constList()[i + 1], indent + 1, true);
            else
                result += " " + formatted_node;
        }
        else if (is_multiline)
            result += "\n" + format(node.constList()[i + 1], indent + 1, true);
        else if (kind == CallKind::List && i == 0)
            result += formatted_node;
        else  // put all arguments on the same line
            result += " " + formatted_node;
    }
    if (!node.constList().back().commentAfter().empty())
        result += "\n" + prefix(indent);
 
    result += kind == CallKind::List ? "]" : ")";
    return result;
}
 
std::string Formatter::formatMacro(const Node& node, const std::size_t indent)
{
    if (isListStartingWithKeyword(node, Keyword::If))
        return formatCondition(node, indent, /* is_macro= */ true);
 
    std::string result = "(macro ";
    bool after_newline = false;
 
    for (std::size_t i = 0, end = node.constList().size(); i < end; ++i)
    {
        result += format(node.constList()[i], indent + 1, after_newline);
        after_newline = false;
 
        if (!node.constList()[i].commentAfter().empty())
        {
            result += "\n";
            after_newline = true;
        }
        else if (i != end - 1)
            result += " ";
    }
 
    return result + ")";
}