use crate::types::Label;
use crate::Result;
use pretty::RcDoc;
#[derive(Debug, Clone)]
pub enum IDLType {
PrimT(PrimType),
VarT(String),
FuncT(FuncType),
OptT(Box<IDLType>),
VecT(Box<IDLType>),
RecordT(Vec<TypeField>),
VariantT(Vec<TypeField>),
ServT(Vec<Binding>),
ClassT(Vec<IDLType>, Box<IDLType>),
PrincipalT,
}
#[derive(Debug, Clone)]
pub struct IDLTypes {
pub args: Vec<IDLType>,
}
macro_rules! enum_to_doc {
(pub enum $name:ident {
$($variant:ident),*,
}) => {
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum $name {
$($variant),*
}
impl $name {
pub(crate) fn to_doc(&self) -> RcDoc<()> {
match self {
$($name::$variant => RcDoc::text(stringify!($variant).to_lowercase())),*
}
}
pub fn str_to_enum(str: &str) -> Option<Self> {
$(if str == stringify!($variant).to_lowercase() {
return Some($name::$variant);
});*
return None;
}
}
};
}
enum_to_doc! {
pub enum PrimType {
Nat,
Nat8,
Nat16,
Nat32,
Nat64,
Int,
Int8,
Int16,
Int32,
Int64,
Float32,
Float64,
Bool,
Text,
Null,
Reserved,
Empty,
}}
enum_to_doc! {
pub enum FuncMode {
Oneway,
Query,
}}
#[derive(Debug, Clone)]
pub struct FuncType {
pub modes: Vec<FuncMode>,
pub args: Vec<IDLType>,
pub rets: Vec<IDLType>,
}
impl FuncType {
pub fn is_query(&self) -> bool {
for m in self.modes.iter() {
if let FuncMode::Query = m {
return true;
}
}
false
}
}
#[derive(Debug, Clone)]
pub struct TypeField {
pub label: Label,
pub typ: IDLType,
}
#[derive(Debug)]
pub enum Dec {
TypD(Binding),
ImportD(String),
}
#[derive(Debug, Clone)]
pub struct Binding {
pub id: String,
pub typ: IDLType,
}
#[derive(Debug)]
pub struct IDLProg {
pub decs: Vec<Dec>,
pub actor: Option<IDLType>,
}
impl std::str::FromStr for IDLProg {
type Err = crate::Error;
fn from_str(str: &str) -> Result<Self> {
let lexer = super::token::Tokenizer::new(str);
Ok(super::grammar::IDLProgParser::new().parse(lexer)?)
}
}
impl std::str::FromStr for IDLType {
type Err = crate::Error;
fn from_str(str: &str) -> Result<Self> {
let lexer = super::token::Tokenizer::new(str);
Ok(super::grammar::TypParser::new().parse(lexer)?)
}
}
impl std::str::FromStr for IDLTypes {
type Err = crate::Error;
fn from_str(str: &str) -> Result<Self> {
let lexer = super::token::Tokenizer::new(str);
Ok(super::grammar::TypsParser::new().parse(lexer)?)
}
}
pub trait ToDoc {
fn to_doc(&self) -> RcDoc<()>;
}
pub fn to_pretty<T>(doc: &T, width: usize) -> String
where
T: ToDoc,
{
let mut w = Vec::new();
doc.to_doc().render(width, &mut w).unwrap();
String::from_utf8(w).unwrap()
}
impl ToDoc for IDLProg {
fn to_doc(&self) -> RcDoc<()> {
let doc = RcDoc::concat(
self.decs
.iter()
.map(|d| d.to_doc().append(RcDoc::text(";").append(RcDoc::line()))),
);
if self.actor.is_some() {
let actor = self.actor.as_ref().unwrap();
let doc = doc.append(RcDoc::text("service : "));
match actor {
IDLType::VarT(ref var) => doc.append(RcDoc::text(var.to_string())),
IDLType::ServT(ref meths) => doc.append(meths_to_doc(meths)),
_ => unreachable!(),
}
} else {
doc
}
}
}
impl ToDoc for Dec {
fn to_doc(&self) -> RcDoc<()> {
match *self {
Dec::TypD(ref b) => RcDoc::text("type ").append(b.to_doc()),
Dec::ImportD(ref file) => RcDoc::text(format!("import \"{}\"", file)),
}
}
}
impl ToDoc for Binding {
fn to_doc(&self) -> RcDoc<()> {
RcDoc::text(format!("{} =", self.id))
.append(RcDoc::space())
.append(self.typ.to_doc())
.nest(2)
.group()
}
}
impl ToDoc for IDLType {
fn to_doc(&self) -> RcDoc<()> {
match self {
IDLType::PrimT(p) => p.to_doc(),
IDLType::VarT(var) => RcDoc::text(var),
IDLType::FuncT(func) => RcDoc::text("func")
.append(RcDoc::space())
.append(func.to_doc()),
IDLType::OptT(ref t) => RcDoc::text("opt").append(RcDoc::space()).append(t.to_doc()),
IDLType::VecT(ref t) => RcDoc::text("vec").append(RcDoc::space()).append(t.to_doc()),
IDLType::RecordT(ref fs) => RcDoc::text("record ").append(fields_to_doc(fs)),
IDLType::VariantT(ref fs) => RcDoc::text("variant ").append(fields_to_doc(fs)),
IDLType::ServT(ref serv) => RcDoc::text("service ").append(meths_to_doc(serv)),
IDLType::ClassT(_, _) => unreachable!(),
IDLType::PrincipalT => RcDoc::text("principal"),
}
.nest(2)
.group()
}
}
impl ToDoc for FuncType {
fn to_doc(&self) -> RcDoc<()> {
args_to_doc(&self.args)
.append(RcDoc::space())
.append(RcDoc::text("-> "))
.append(args_to_doc(&self.rets))
.append(RcDoc::concat(
self.modes.iter().map(|m| RcDoc::space().append(m.to_doc())),
))
}
}
impl ToDoc for TypeField {
fn to_doc(&self) -> RcDoc<()> {
let colon = RcDoc::text(":").append(RcDoc::space());
let doc = match &self.label {
Label::Id(n) => RcDoc::as_string(n).append(colon),
Label::Named(name) => RcDoc::text(name).append(colon),
Label::Unnamed(_) => RcDoc::nil(),
};
doc.append(self.typ.to_doc()).nest(2).group()
}
}
fn fields_to_doc(fields: &[TypeField]) -> RcDoc<()> {
RcDoc::text("{")
.append(
RcDoc::concat(
fields
.iter()
.map(|f| RcDoc::space().append(f.to_doc()).append(RcDoc::text(";"))),
)
.nest(2)
.group(),
)
.append(RcDoc::space())
.append(RcDoc::text("}"))
}
fn meths_to_doc(meths: &[Binding]) -> RcDoc<()> {
RcDoc::text("{")
.append(RcDoc::concat(meths.iter().map(|meth| {
let doc = RcDoc::line().append(RcDoc::text(format!("{}:", meth.id)));
let doc = match meth.typ {
IDLType::VarT(ref var) => doc.append(RcDoc::space().append(RcDoc::text(var))),
IDLType::FuncT(ref func) => {
doc.append(RcDoc::space().append(func.to_doc()).nest(2))
}
_ => unreachable!(),
}
.nest(2)
.group();
doc.append(RcDoc::text(";"))
})))
.append(RcDoc::space())
.append(RcDoc::text("}"))
}
fn args_to_doc(args: &[IDLType]) -> RcDoc<()> {
RcDoc::text("(")
.append(
RcDoc::intersperse(
args.iter().map(|arg| arg.to_doc()),
RcDoc::text(",").append(RcDoc::space()),
)
.nest(1)
.group(),
)
.append(")")
}