tame/tamer/src/asg/air/tpl.rs

386 lines
12 KiB
Rust

// ASG IR template parsing
//
// Copyright (C) 2014-2023 Ryan Specialty, LLC.
//
// This file is part of TAME.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//! AIR template parser.
//!
//! See the [parent module](super) for more information.
use super::{
super::{graph::object::Tpl, Asg, AsgError, ObjectIndex},
ir::AirTemplatable,
AirAggregateCtx, AirExprAggregate,
};
use crate::{
asg::graph::object::{Meta, ObjectIndexRelTo},
diagnose::Annotate,
diagnostic_todo,
fmt::{DisplayWrapper, TtQuote},
parse::prelude::*,
span::Span,
};
/// Template parser and token aggregator.
///
/// A template consists of
///
/// - Metadata about the template,
/// including its parameters; and
/// - A collection of [`AirTemplatable`] tokens representing the body of
/// the template that will be expanded into the application site when
/// the template is applied.
///
/// This contains an embedded [`AirExprAggregate`] parser for handling
/// expressions just the same as [`super::AirAggregate`] does with
/// packages.
#[derive(Debug, PartialEq)]
pub enum AirTplAggregate {
/// Ready for a template,
/// defined as part of the given package.
///
/// This state also includes the template header;
/// unlike NIR,
/// AIR has no restrictions on when template header tokens are
/// provided,
/// which simplifies AIR generation.
Ready,
/// Toplevel template context.
///
/// Conceptually,
/// tokens that are received in this state are interpreted as directly
/// applying to the template itself,
/// or creating an object directly owned by the template.
Toplevel(TplState),
/// Defining a template metavariable.
TplMeta(TplState, ObjectIndex<Meta>),
/// Aggregating tokens into a template.
TplExpr(TplState, AirExprAggregate),
}
impl Display for AirTplAggregate {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
Self::Ready => write!(f, "ready for template definition"),
Self::Toplevel(tpl) => write!(f, "building {tpl} at toplevel"),
Self::TplExpr(tpl, expr) => {
write!(f, "building {tpl} with {expr}")
}
Self::TplMeta(tpl, _) => {
write!(f, "building {tpl} metavariable")
}
}
}
}
/// The current reachability status of the template.
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum TplState {
/// Template is dangling and cannot be referenced by anything else.
Dangling(ObjectIndex<Tpl>),
/// Template is anonymous and is not reachable by an identifier,
/// but is reachable in the current context.
AnonymousReachable(ObjectIndex<Tpl>),
/// Template is reachable via an identifier.
///
/// This uses an [`SPair`] as evidence for that assertion rather than an
/// [`ObjectIndex`] so that it provides useful output via [`Display`]
/// in parser traces.
Identified(ObjectIndex<Tpl>, SPair),
}
impl TplState {
fn oi(&self) -> ObjectIndex<Tpl> {
match self {
TplState::Dangling(oi)
| TplState::AnonymousReachable(oi)
| TplState::Identified(oi, _) => *oi,
}
}
fn identify(self, id: SPair) -> Self {
Self::Identified(self.oi(), id)
}
fn anonymous_reachable(self) -> Self {
Self::AnonymousReachable(self.oi())
}
/// Attempt to complete a template definition.
///
/// If `self` is [`Self::Dangling`],
/// then an [`AsgError::DanglingTpl`] will be returned.
///
/// This updates the span of the template to encompass the entire
/// definition,
/// even if an error occurs.
fn close(self, asg: &mut Asg, close_span: Span) -> Result<(), AsgError> {
let oi = self.oi().close(asg, close_span);
match self {
Self::Dangling(_) => {
Err(AsgError::DanglingTpl(oi.resolve(asg).span()))
}
Self::AnonymousReachable(..) | Self::Identified(..) => Ok(()),
}
}
}
impl Display for TplState {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
TplState::Dangling(_) => write!(f, "anonymous dangling template"),
TplState::AnonymousReachable(_) => {
write!(f, "anonymous reachable template")
}
TplState::Identified(_, id) => {
write!(f, "identified template {}", TtQuote::wrap(id))
}
}
}
}
impl ParseState for AirTplAggregate {
type Token = AirTemplatable;
type Object = ();
type Error = AsgError;
type Context = AirAggregateCtx;
fn parse_token(
self,
tok: Self::Token,
ctx: &mut Self::Context,
) -> TransitionResult<Self::Super> {
use super::ir::{AirBind::*, AirTpl::*};
use AirTemplatable::*;
use AirTplAggregate::*;
match (self, tok) {
(Ready, AirTpl(TplStart(span))) => {
let oi_tpl = ctx.asg_mut().create(Tpl::new(span));
Transition(Toplevel(TplState::Dangling(oi_tpl))).incomplete()
}
(Toplevel(..), AirTpl(TplStart(span))) => diagnostic_todo!(
vec![span.note("for this template")],
"nested tpl open"
),
(Toplevel(tpl), AirBind(BindIdent(id))) => {
let oi_root = ctx.rooting_oi().expect("TODO");
let asg = ctx.asg_mut();
asg.lookup_global_or_missing(id)
.bind_definition(asg, id, tpl.oi())
.map(|oi_ident| oi_root.defines(asg, oi_ident))
.map(|_| ())
.transition(Toplevel(tpl.identify(id)))
}
(Toplevel(tpl), AirBind(RefIdent(id))) => {
tpl.oi().apply_named_tpl(ctx.asg_mut(), id);
Transition(Toplevel(tpl)).incomplete()
}
(Toplevel(tpl), AirTpl(TplMetaStart(span))) => {
let oi_meta = ctx.asg_mut().create(Meta::new_required(span));
Transition(TplMeta(tpl, oi_meta)).incomplete()
}
(TplMeta(tpl, oi_meta), AirTpl(TplMetaEnd(cspan))) => {
oi_meta.close(ctx.asg_mut(), cspan);
Transition(Toplevel(tpl)).incomplete()
}
(TplMeta(tpl, oi_meta), AirTpl(TplLexeme(lexeme))) => Transition(
TplMeta(tpl, oi_meta.assign_lexeme(ctx.asg_mut(), lexeme)),
)
.incomplete(),
(TplMeta(tpl, oi_meta), AirBind(BindIdent(name))) => {
oi_meta.identify_as_tpl_param(ctx.asg_mut(), tpl.oi(), name);
Transition(TplMeta(tpl, oi_meta)).incomplete()
}
(TplMeta(..), tok @ AirBind(RefIdent(..))) => {
diagnostic_todo!(
vec![tok.note("this token")],
"AirBind in metavar context (param-value)"
)
}
(TplMeta(..), tok @ AirExpr(..)) => {
diagnostic_todo!(
vec![tok.note("this token")],
"AirExpr in metavar context (e.g. @values@)"
)
}
(
TplMeta(..),
tok @ AirTpl(
TplStart(..) | TplMetaStart(..) | TplEnd(..)
| TplEndRef(..),
),
) => {
diagnostic_todo!(vec![tok.note("this token")], "AirTpl variant")
}
(Toplevel(..), tok @ AirTpl(TplMetaEnd(..))) => {
diagnostic_todo!(
vec![tok.note("this token")],
"unbalanced meta"
)
}
(Toplevel(..), tok @ AirTpl(TplLexeme(..))) => {
diagnostic_todo!(
vec![tok.note("this token")],
"err: TplLexeme outside of metavar"
)
}
(Toplevel(tpl), AirTpl(TplEnd(span))) => {
tpl.close(ctx.asg_mut(), span).transition(Ready)
}
(TplExpr(tpl, expr), AirTpl(TplEnd(span))) => {
// TODO: duplicated with AirAggregate
if expr.is_accepting(ctx) {
ctx.pop();
tpl.close(ctx.asg_mut(), span).transition(Ready)
} else {
Transition(TplExpr(tpl, expr))
.err(AsgError::InvalidTplEndContext(span))
}
}
(Toplevel(tpl), AirTpl(TplEndRef(span))) => {
let oi_target = ctx.expansion_oi().expect("TODO");
tpl.oi().expand_into(ctx.asg_mut(), oi_target);
Transition(Toplevel(tpl.anonymous_reachable()))
.incomplete()
.with_lookahead(AirTpl(TplEnd(span)))
}
(TplExpr(tpl, expr_done), AirTpl(TplEndRef(span))) => {
let oi_target = ctx.expansion_oi().expect("TODO");
tpl.oi().expand_into(ctx.asg_mut(), oi_target);
// TODO: We have to make sure the expression ended first!
Transition(TplExpr(tpl.anonymous_reachable(), expr_done))
.incomplete()
.with_lookahead(AirTpl(TplEnd(span)))
}
(Toplevel(tpl), tok @ AirExpr(_)) => {
ctx.push(Toplevel(tpl));
Transition(TplExpr(tpl, AirExprAggregate::new()))
.incomplete()
.with_lookahead(tok)
}
(TplExpr(tpl, expr), AirExpr(etok)) => {
Self::delegate_expr(ctx, tpl, expr, etok)
}
(TplExpr(tpl, expr), AirBind(etok)) => {
Self::delegate_expr(ctx, tpl, expr, etok)
}
(TplExpr(..), AirTpl(TplStart(span))) => {
diagnostic_todo!(
vec![span.note("for this token")],
"nested template (template-generated template)"
)
}
(
Ready | TplExpr(..),
tok @ AirTpl(TplMetaStart(..) | TplLexeme(..) | TplMetaEnd(..)),
) => {
diagnostic_todo!(
vec![tok.note("for this token")],
"metasyntactic token in non-tpl-toplevel context: {tok:?}"
)
}
(st @ Ready, AirTpl(TplEnd(span) | TplEndRef(span))) => {
Transition(st).err(AsgError::UnbalancedTpl(span))
}
(st @ Ready, tok @ (AirExpr(..) | AirBind(..))) => {
Transition(st).dead(tok)
}
}
}
fn is_accepting(&self, _: &Self::Context) -> bool {
matches!(self, Self::Ready)
}
}
impl AirTplAggregate {
pub(super) fn new() -> Self {
Self::Ready
}
pub(super) fn active_tpl_oi(&self) -> Option<ObjectIndex<Tpl>> {
use AirTplAggregate::*;
match self {
Ready => None,
Toplevel(tplst) | TplMeta(tplst, _) | TplExpr(tplst, _) => {
Some(tplst.oi())
}
}
}
/// Delegate to the expression parser [`AirExprAggregate`].
fn delegate_expr(
asg: &mut <Self as ParseState>::Context,
tpl: TplState,
expr: AirExprAggregate,
etok: impl Into<<AirExprAggregate as ParseState>::Token>,
) -> TransitionResult<Self> {
let tok = etok.into();
expr.parse_token(tok, asg).branch_dead::<Self, _>(
|_, ()| Transition(Self::Toplevel(tpl)).incomplete(),
|expr, result, ()| {
result
.map(ParseStatus::reflexivity)
.transition(Self::TplExpr(tpl, expr))
},
(),
)
}
}
#[cfg(test)]
mod test;