stream.cpp

Go to the documentation of this file.

#include <ostream>
 
#include "mim/ast/ast.h"
#include "mim/ast/lexer.h"
 
namespace mim::ast {
 
using Tag = Tok::Tag;
 
struct S {
    S(fe::Tab& tab, const Node* node)
        : tab(tab)
        , node(node) {}
 
    fe::Tab& tab;
    const Node* node;
 
    friend std::ostream& operator<<(std::ostream& os, const S& s) { return s.node->stream(s.tab, os), os; }
};
 
} // namespace mim::ast
 
#ifndef DOXYGEN
template<>
struct std::formatter<mim::ast::S> : fe::ostream_formatter {};
#endif
 
namespace mim::ast {
 
template<class T>
struct R {
    R(fe::Tab& tab, fe::View<Ptr<T>> range, std::string_view sep = ", ")
        : tab(tab)
        , range(range)
        , sep(sep) {}
 
    fe::Tab& tab;
    fe::View<Ptr<T>> range;
    std::string_view sep;
 
    friend std::ostream& operator<<(std::ostream& os, const R& r) {
        for (std::string_view curr_sep{}; const auto& ptr : r.range) {
            os << curr_sep;
            ptr->stream(r.tab, os);
            curr_sep = r.sep;
        }
        return os;
    }
};
 
} // namespace mim::ast
 
#ifndef DOXYGEN
template<class T>
struct std::formatter<mim::ast::R<T>> : fe::ostream_formatter {};
#endif
 
namespace mim::ast {
 
template<class T>
static void stream_decls(fe::Tab& tab, std::ostream& os, fe::View<Ptr<T>> decls) {
    for (auto decl : decls)
        std::println(os, "{}{}", tab, S(tab, decl.get()));
}
 
void Node::dump() const {
    auto tab = fe::Tab::spaces();
    stream(tab, std::cout);
    std::cout << std::endl;
}
 
/*
 * File
 */
 
void File::stream(fe::Tab& tab, std::ostream& os) const { stream_decls(tab, os, decls()); }
 
/*
 * Ptrn
 */
 
void ErrorPtrn::stream(fe::Tab&, std::ostream& os) const { os << "<error pattern>"; }
void AliasPtrn::stream(fe::Tab& tab, std::ostream& os) const { std::print(os, "{}: {}", S(tab, ptrn()), dbg()); }
void GrpPtrn::stream(fe::Tab&, std::ostream& os) const { os << dbg(); }
 
void IdPtrn::stream(fe::Tab& tab, std::ostream& os) const {
    // clang-format off
    if ( dbg() &&  type()) { std::print(os, "{}: {}", dbg(), S(tab, type())); return; }
    if ( dbg() && !type()) { std::print(os, "{}", dbg()); return; }
    if (!dbg() &&  type()) { std::print(os, "{}", S(tab, type())); return; }
    // clang-format on
    os << "<invalid identifier pattern>";
}
 
void TuplePtrn::stream(fe::Tab& tab, std::ostream& os) const {
    std::print(os, "{}{}{}", delim_l(), R(tab, ptrns()), delim_r());
}
 
/*
 * Expr
 */
 
void Path::stream(fe::Tab&, std::ostream& os) const { std::print(os, "{}", fe::Join(dbgs(), ".")); }
 
void PathExpr::stream(fe::Tab& tab, std::ostream& os) const { path()->stream(tab, os); }
void ErrorExpr::stream(fe::Tab&, std::ostream& os) const { os << "<error expression>"; }
void HoleExpr::stream(fe::Tab&, std::ostream& os) const { os << "?"; }
void PrimaryExpr::stream(fe::Tab&, std::ostream& os) const { std::print(os, "{}", tag()); }
 
void LitExpr::stream(fe::Tab& tab, std::ostream& os) const {
    switch (tag()) {
        case Tag::L_i: {
            auto [size, val] = tok().lit_i();
            std::print(os, "{}_{}", val, size); // the `_` form spells out every size, 2^64 included
            return;
        }
        case Tag::L_f: os << std::bit_cast<double>(tok().lit_u()); return;
        case Tag::L_s:
        case Tag::L_u:
            os << tok().lit_u();
            if (type()) std::print(os, ": {}", S(tab, type()));
            return;
        default: os << "TODO";
    }
}
 
void DeclExpr::stream(fe::Tab& tab, std::ostream& os) const {
    if (is_where()) {
        std::println(os, "{}{} where", tab, S(tab, expr()));
        ++tab;
        stream_decls(tab, os, decls());
        --tab;
    } else {
        stream_decls(tab, os, decls());
        std::print(os, "{}", S(tab, expr()));
    }
}
 
void TypeExpr::stream(fe::Tab& tab, std::ostream& os) const { std::print(os, "(Type {})", S(tab, level())); }
void RuleExpr::stream(fe::Tab& tab, std::ostream& os) const { std::print(os, "(Rule {})", S(tab, dom())); }
 
void InfixExpr::stream(fe::Tab& tab, std::ostream& os) const {
    std::print(os, "({} {} {})", S(tab, lhs()), Tok::tag2str(op().tag()), S(tab, rhs()));
}
 
void MatchExpr::Arm::stream(fe::Tab& tab, std::ostream& os) const {
    std::print(os, "{} => {}", S(tab, ptrn()), S(tab, body()));
}
 
void MatchExpr::stream(fe::Tab& tab, std::ostream& os) const {
    std::println(os, "{}match {} with", tab, S(tab, scrutinee()));
    ++tab;
    for (auto arm : arms())
        std::println(os, "{}| {}", tab, S(tab, arm.get()));
    --tab;
    std::println(os, "{}}}", tab);
}
 
void PiExpr::Dom::stream(fe::Tab& tab, std::ostream& os) const {
    std::print(os, "{}{}", is_implicit() ? "." : "", S(tab, ptrn()));
    if (ret()) std::print(os, " -> {}", S(tab, ret()->type()));
}
 
void PiExpr::stream(fe::Tab& tab, std::ostream& os) const {
    if (tag() != Tag::Nil) std::print(os, "{} ", tag());
    std::print(os, "{}", S(tab, dom()));
    if (codom()) std::print(os, " -> {}", S(tab, codom()));
}
 
void LamExpr::stream(fe::Tab& tab, std::ostream& os) const { std::print(os, "{};", S(tab, lam())); }
 
void AppExpr::stream(fe::Tab& tab, std::ostream& os) const {
    std::print(os, "({} {})", S(tab, callee()), S(tab, arg()));
}
 
void RetExpr::stream(fe::Tab& tab, std::ostream& os) const {
    std::println(os, "ret {} = {} $ {};", S(tab, ptrn()), S(tab, callee()), S(tab, arg()));
    std::print(os, "{}{}", tab, S(tab, body()));
}
 
void SigmaExpr::stream(fe::Tab& tab, std::ostream& os) const { ptrn()->stream(tab, os); }
void TupleExpr::stream(fe::Tab& tab, std::ostream& os) const { std::print(os, "({})", R(tab, elems())); }
 
void SeqExpr::stream(fe::Tab& tab, std::ostream& os) const {
    std::print(os, "{}{}; {}{}", is_pack() ? "‹" : "«", S(tab, arity()), S(tab, body()), is_pack() ? "›" : "»");
}
 
void UniqExpr::stream(fe::Tab& tab, std::ostream& os) const { std::print(os, "⦃{}⦄", S(tab, inhabitant())); }
 
/*
 * Decl
 */
 
static std::string_view vis2str(Vis vis) {
    switch (vis) {
        case Vis::Priv: return "priv";
        case Vis::Pub: return "pub";
    }
    fe::unreachable();
}
 
/// Prints `vis`/`extern`/`anx`, skipping `vis` if it's the modifier-nudged Mods::default_vis.
static std::ostream& operator<<(std::ostream& os, const Mods& mods) {
    if (auto vis = mods.resolved_vis(); vis != mods.default_vis()) std::print(os, "{} ", vis2str(vis));
    if (mods.is_extern) std::print(os, "extern ");
    if (mods.is_anx) std::print(os, "anx ");
    return os;
}
 
} // namespace mim::ast
 
#ifndef DOXYGEN
template<>
struct std::formatter<mim::ast::Mods> : fe::ostream_formatter {};
#endif
 
namespace mim::ast {
 
void AxmDecl::stream(fe::Tab& tab, std::ostream& os) const {
    if (vis() == Vis::Priv) std::print(os, "priv "); // `axm` is always anx, so it's never printed here
    std::print(os, "axm {}: {}", dbg(), S(tab, type()));
    if (normalizer()) std::print(os, ", {}", normalizer());
    if (curry()) std::print(os, ", {}", curry());
    if (trip()) std::print(os, ", {}", trip());
    os << ";";
}
 
void AxmDecl::Sibling::stream(fe::Tab& tab, std::ostream& os) const {
    if (vis() == Vis::Priv) std::print(os, "priv "); // `axm` is always anx, so it's never printed here
    std::print(os, "axm {}: {}", dbg(), S(tab, owner()->type()));
    if (owner()->normalizer()) std::print(os, ", {}", owner()->normalizer());
    os << ";";
}
 
void AliasDecl::stream(fe::Tab& tab, std::ostream& os) const {
    if (vis() == Vis::Priv) std::print(os, "priv ");
    std::print(os, "anx {} = {};", dbg(), S(tab, path()));
}
 
void ModDecl::stream(fe::Tab& tab, std::ostream& os) const {
    std::println(os, "{}mod {} {{", mods(), dbg());
    ++tab;
    stream_decls(tab, os, decls());
    --tab;
    std::print(os, "{}}}", tab);
}
 
void UseDecl::stream(fe::Tab& tab, std::ostream& os) const {
    if (is_file_path())
        std::print(os, "{}{} \"{}\"", mods(), tag(), Lexer::escape(file_path().view()));
    else
        std::print(os, "{}{} {}", mods(), tag(), S(tab, path()));
    if (alias()) std::print(os, " as {}", alias());
    if (is_splice() && is_import()) std::print(os, " as {}", Tag::T_star);
    os << ';';
}
 
void LetDecl::stream(fe::Tab& tab, std::ostream& os) const {
    std::print(os, "{}let {} = {};", mods(), S(tab, ptrn()), S(tab, value()));
}
 
void RecDecl::stream(fe::Tab& tab, std::ostream& os) const {
    std::print(os, "{}{}", mods(), isa<LamDecl>() ? "" : "rec ");
    stream_(tab, os);
    for (auto curr = next(); curr; curr = curr->next()) {
        std::println(os);
        std::print(os, "{}and ", tab);
        curr->stream_(tab, os);
    }
    os << ';';
}
 
void RecDecl::stream_(fe::Tab& tab, std::ostream& os) const { std::print(os, "{} = {}", dbg(), S(tab, body())); }
 
void LamDecl::Dom::stream(fe::Tab& tab, std::ostream& os) const {
    std::print(os, "{}{}", is_implicit() ? "." : "", S(tab, ptrn()));
    if (filter()) std::print(os, "@({})", S(tab, filter()));
    if (ret()) std::print(os, ": {}", S(tab, ret()->type()));
}
 
void LamDecl::stream_(fe::Tab& tab, std::ostream& os) const {
    std::print(os, "{} {}", tag(), dbg());
    if (!doms().front()->ptrn()->isa<TuplePtrn>()) os << ' ';
    std::print(os, "{}", R(tab, doms()));
    if (codom()) std::print(os, ": {}", S(tab, codom()));
    if (body()) {
        if (body()->isa<DeclExpr>()) {
            os << " =" << std::endl;
            ++tab;
            std::print(os, "{}{}", tab, S(tab, body()));
            --tab;
        } else {
            std::print(os, " = {}", S(tab, body()));
        }
    }
}
 
void RuleDecl::stream(fe::Tab& tab, std::ostream& os) const {
    std::print(os, "rule {} : {} => {} when {}", S(tab, var()), S(tab, lhs()), S(tab, rhs()), S(tab, guard()));
}
} // namespace mim::ast