parser.h

Go to the documentation of this file.

#pragma once
 
#include <fe/parser.h>
 
#include "mim/ast/ast.h"
#include "mim/ast/lexer.h"
 
namespace mim::ast {
 
constexpr size_t Look_Ahead = 2;
 
/// Parses Mim code as AST.
///
/// The logic behind the various parse methods is as follows:
/// 1. The `parse_*` method does **not** have a `fe::Cite ctxt` parameter:
///
///     It's the **caller's responsibility** to first make appropriate
///     [FIRST/FOLLOW](https://www.cs.uaf.edu/~cs331/notes/FirstFollow.pdf) checks.
///     Otherwise, an assertion will be triggered in the case of a syntax error.
///
/// 2. The `parse_*` method does have a `fe::Cite ctxt` parameter:
///
///      The **called method** checks this and spits out an appropriate error message using `ctxt` in the case of a
///      syntax error.
///
/// 3. The `parse_*` method does have a `fe::Cite ctxt = {}` parameter **with default argument**:
///
///      * If default argument is **elided** we have the same behavior as in 1.
///      * If default argument is **provided** we have the same behavior as in 2.
class Parser : public fe::Parser<Tok, Tok::Tag, Look_Ahead, Parser> {
    using Super = fe::Parser<Tok, Tok::Tag, Look_Ahead, Parser>;
 
public:
    Parser(AST& ast)
        : ast_(ast) {}
 
    AST& ast() { return ast_; }
    Driver& driver() { return ast().driver(); } ///< fe::Parser's default diagnostics go to its Driver::error.
    Lexer& lexer() { return *lexer_; }          ///< fe::Parser::lex pulls the next Tok%en from here.
    const File* import(std::string_view sv, Tok::Tag tag = Tok::Tag::K_import) {
        return import({Loc(), driver().sym(sv)}, false, tag, nullptr);
    }
    /// @p is_path selects the `import "some/path.mim"` form over the search-path lookup by name.
    /// @p record is `false` for the compilation root: it is not a directive that a dump should reproduce.
    const File*
    import(Dbg, bool is_path, Tok::Tag tag = Tok::Tag::K_import, std::ostream* md = nullptr, bool record = true);
    const File* import(const fe::Src&, std::ostream* md = nullptr, Loc = {});
    /// Imports the @p plugins the Driver was told about via `-p` as anonymous, unaliased UseDecl%s.
    Ptrs<UseDecl> import_plugins(fe::View<std::string> plugins, Tok::Tag);
    /// Slurps @p is, registers it in Driver::src under @p path, and parses it.
    const File* import(std::istream& is, fs::path path, Loc = {}, std::ostream* md = nullptr);
    const File* import_main(std::string_view input, fe::View<std::string> plugins, std::ostream* md = nullptr);
 
private:
    template<class T, class... Args>
    auto ptr(Args&&... args) {
        return ast_.ptr<const T>(std::forward<Args>(args)...);
    }
 
    /// Empty Loc right after the last consumed token - where a node sits that is *missing* rather than wrong.
    Loc missing() const { return curr_.anew_end(); }
 
    /// @name parse misc
    ///@{
    Ptr<File> parse_file();
    Dbg parse_id(fe::Cite ctxt = {});
    Ptr<Path> parse_path(fe::Cite ctxt = {});
    Ptr<UseDecl> parse_import_or_plugin(Tracker, Mods);
    Ptr<Expr> parse_type_ascr(fe::Cite ctxt);
 
    /// Directory of the file currently being parsed; empty if its Loc%s have no fe::Src.
    fs::path curr_dir() const { return curr_.src ? curr_.src->path().parent_path() : fs::path(); }
    /// A Path of a single component.
    Ptr<Path> path(Dbg dbg) { return ptr<Path>(dbg.loc(), Dbgs{dbg}); }
    Ptr<Expr> path_expr(Dbg dbg) { return ptr<PathExpr>(path(dbg)); }
 
    void parse_list(fe::Cite ctxt, Tok::Tag delim_l, std::invocable auto f, Tok::Tag sep = Tok::Tag::T_comma) {
        auto delim_r = Tok::delim_l2r(delim_l);
        auto _       = anchor(expect(delim_l, ctxt), delim_r);
        do {
            recover(ctxt);
            if (ahead().isa(delim_r)) break;
            f();
            recover(ctxt);
        } while (accept(sep));
        expect(delim_r, "closing delimiter of a {}", ctxt);
    }
 
    /// Discard all closing delimiters that no enclosing context is waiting for.
    void recover(fe::Cite ctxt) { Super::recover(Tok::is_delim_r, ctxt); }
    ///@}
 
    /// @name parse exprs
    ///@{
    Ptr<Expr> parse_expr(fe::Cite ctxt, Prec = Prec::Bot);
 
    /// As above but builds @p ctxt via fe::format_cite.
    template<class... Args>
    Ptr<Expr> parse_expr(fe::cite_string<Args...> fmt, Args&&... args) {
        return parse_expr(fe::format_cite(fmt, std::forward<Args>(args)...));
    }
 
    /// As above but with @p prec.
    template<class... Args>
    Ptr<Expr> parse_expr(Prec prec, fe::cite_string<Args...> fmt, Args&&... args) {
        return parse_expr(fe::format_cite(fmt, std::forward<Args>(args)...), prec);
    }
    Ptr<Expr> parse_primary_expr(fe::Cite ctxt);
    Ptr<Expr> parse_prefix_expr();
    Ptr<Expr> parse_infix_expr(Tracker, Ptr<Expr> lhs, Prec = Prec::Bot, fe::Cite ctxt = {});
 
    /// The `` `op `` a MIM_INFIX_SUGAR operator desugars to; `nullptr` for a MIM_INFIX_CORE one.
    Ptr<Expr> sugar_callee(Tok op);
    ///@}
 
    /// @name parse primary exprs
    ///@{
    Ptr<Expr> parse_decl_expr();
    Ptr<Expr> parse_lit_expr();
    Ptr<Expr> parse_type_expr();
    Ptr<Expr> parse_rule_expr();
    Ptr<Expr> parse_ret_expr();
    Ptr<Expr> parse_pi_expr();
    Ptr<Expr> parse_pi_expr(Ptr<Ptrn>);
    Ptr<Expr> parse_lam_expr();
    Ptr<Expr> parse_seq_or_single_expr();
    Ptr<Expr> parse_sigma_expr();
    Ptr<Expr> parse_tuple_expr();
    Ptr<Expr> parse_match_expr();
    Ptr<Expr> parse_variant_expr();
    ///@}
 
    /// @name parse ptrns
    ///@{
 
    /// A pattern `p` binds names for a body, whereas a telescope `b` (PtrnStyle::brckt) describes a type and names a
    /// component only so that later components or the codomain may depend on it.
    struct PtrnStyle {
        bool brckt    = false;
        bool implicit = false; ///< Also accept `{p, ..., p}` / `{b, ..., b}`.
    };
 
    Ptr<Ptrn> parse_ptrn(PtrnStyle, fe::Cite ctxt, Prec = Prec::Bot);
 
    /// As above but builds @p ctxt via fe::format_cite.
    template<class... Args>
    Ptr<Ptrn> parse_ptrn(PtrnStyle style, Prec prec, fe::cite_string<Args...> fmt, Args&&... args) {
        return parse_ptrn(style, fe::format_cite(fmt, std::forward<Args>(args)...), prec);
    }
    Ptr<Ptrn> parse_ptrn_(PtrnStyle, fe::Cite ctxt, Prec = Prec::Bot);
    Ptr<TuplePtrn> parse_tuple_ptrn(PtrnStyle);
 
    /// The empty Sym - as opposed to `_` - is what lets Ptrn::to_expr turn this binder back into an expression.
    Ptr<IdPtrn> anon_ptrn(Loc loc, Ptr<Expr> type) { return ptr<IdPtrn>(loc, Dbg(loc.anew_begin()), type); }
    ///@}
 
    /// @name parse decls
    ///@{
    Ptrs<ValDecl> parse_decls(Mods group = {});
 
    /// Parses any combination of `priv`/`pub`/`extern`/`anx` modifier tokens, in any order.
    /// Only rejects a modifier being repeated (`priv priv`, `extern extern`, ...);
    /// whether a given combination makes sense for the decl that follows is up to that decl's own parser.
    Mods parse_modifiers();
    /// Errors if @p mods sets `extern`, for decl kinds that don't support it (`let`/bare `rec`):
    /// currently only a function declaration (`lam`/`con`/`fun`, see Parser::parse_lam_decl) may be `extern`.
    /// The default-`Vis` nudge itself lives in Mods::default_vis, resolved lazily by ValDecl::vis.
    void check_no_extern(const Mods&, fe::Cite entity);
    Ptr<ValDecl> parse_axm_decl(Tracker, Mods);
    /// `(tag_0 [= alias]*, ...)` of an `axm` family.
    Ptrs<AxmDecl::Name> parse_axm_names();
    std::tuple<Ptr<Expr>, Dbg, Tok, Tok> parse_axm_tail();
    Ptr<ValDecl> parse_alias_decl(Tracker, Mods);
    Ptr<ValDecl> parse_let_decl(Tracker, Mods);
    Ptr<ValDecl> parse_mod_decl(Tracker, Mods);
    Ptr<RecDecl> parse_nom_decl(Tracker, Mods);
    Ptr<ValDecl> parse_use_decl(Tracker, Mods);
    Ptr<ValDecl> parse_rule_decl(Tracker, Mods);
    Ptr<LamDecl> parse_lam_decl(Tracker, Mods);
    Ptr<RecDecl> parse_rec_decl(Tracker, Mods);
    Ptr<ValDecl> parse_mutual_decl(Tracker, Mods);
    ///@}
 
    AST& ast_;
    Lexer* lexer_ = nullptr;
 
    friend Super;
};
 
} // namespace mim::ast