use std::collections::HashMap;
use tpt_telos_parser::ast::*;
use crate::{
analyze_func, collect_types, render_expr_doc, render_params_sig, InputParam, TypeFields,
};
pub(crate) fn exported(name: &str) -> String {
let mut chars = name.chars();
match chars.next() {
Some(c) => c.to_ascii_uppercase().to_string() + chars.as_str(),
None => String::new(),
}
}
fn receiver(ty: &str) -> String {
ty.chars()
.next()
.map(|c| c.to_ascii_lowercase().to_string())
.unwrap_or_else(|| "r".to_string())
}
pub fn generate_go_package(
modules: &[&Module],
bodies: &HashMap<String, Vec<Stmt>>,
package: &str,
) -> String {
let mut out = String::new();
out.push_str("// Generated by tpt-telos. Do not edit by hand.\n");
out.push_str("// Mathematical contracts were verified by the tpt-telos SMT core.\n");
out.push_str(&format!("package {}\n\n", package));
let mut struct_types: TypeFields = HashMap::new();
for m in modules {
collect_types(m, &mut struct_types);
}
for m in modules {
out.push_str(&generate_module(m, bodies, &struct_types));
out.push('\n');
}
normalize(out)
}
pub(crate) fn normalize(mut s: String) -> String {
while s.ends_with('\n') {
s.pop();
}
s.push('\n');
s
}
fn generate_module(
module: &Module,
bodies: &HashMap<String, Vec<Stmt>>,
types: &TypeFields,
) -> String {
let route = tpt_telos_router::route(&module.attributes);
let is_persistent = route.storage == tpt_telos_router::StorageClass::Persistent;
let mut out = String::new();
out.push_str(&format!(
"// ===== module {} (target: {}, storage: {}) =====\n",
module.name,
route.target.as_str(),
if is_persistent {
"persistent"
} else {
"ephemeral"
}
));
let mut tys: Vec<(&String, &Vec<(String, tpt_telos_parser::ast::Type)>)> =
types.iter().collect();
tys.sort_by(|a, b| a.0.cmp(b.0));
for (ty, fields) in tys {
if fields.is_empty() {
continue;
}
out.push_str(&format!("type {} struct {{\n", ty));
for (f, fty) in fields {
if is_persistent {
out.push_str(&format!(
"\t{} {} `json:\"{}\"`\n",
exported(f),
render_type_go(fty),
f
));
} else {
out.push_str(&format!("\t{} {}\n", exported(f), render_type_go(fty)));
}
}
out.push_str("}\n\n");
}
for item in &module.items {
if let Item::Invariant(inv) = item {
let recv = receiver(&inv.name);
let conds = inv
.constraints
.iter()
.map(|c| render_inv(c, &recv))
.collect::<Vec<_>>()
.join(" && ");
out.push_str(&format!(
"// SatisfiesInvariants reports whether the {name} invariant holds.\n\
func ({recv} *{name}) SatisfiesInvariants() bool {{\n\treturn {conds}\n}}\n\n",
name = inv.name,
recv = recv,
conds = conds
));
}
}
for item in &module.items {
if let Item::Func(f) = item {
let stmts = bodies
.get(&f.name)
.cloned()
.unwrap_or_else(|| f.body.clone());
if f.is_ejected() {
out.push_str(&crate::eject::render_go_ejected(f, &stmts, types));
} else {
out.push_str(&render_func(f, &stmts, types));
}
out.push('\n');
}
}
out
}
fn render_func(f: &Func, stmts: &[Stmt], types: &TypeFields) -> String {
render_func_named(f, stmts, types, &exported(&f.name))
}
pub(crate) fn render_func_named(
f: &Func,
stmts: &[Stmt],
types: &TypeFields,
name: &str,
) -> String {
let mut out = String::new();
out.push_str(&format!(
"// {} implements {}({})\n",
name,
f.name,
render_params_sig(f)
));
for r in &f.requires {
out.push_str(&format!("// requires: {}\n", render_expr_doc(r)));
}
for e in &f.ensures {
out.push_str(&format!("// ensures: {}\n", render_expr_doc(e)));
}
let analysis = analyze_func(f, stmts, types);
let mut params = Vec::new();
for input in &analysis.inputs {
match input {
InputParam::Scalar { name } => params.push(format!("{} int64", name)),
InputParam::Struct {
name, ty, mutated, ..
} => {
if *mutated {
params.push(format!("{} *{}", name, ty));
} else {
params.push(format!("{} {}", name, ty));
}
}
}
}
let ret = if analysis.scalar_out.is_some() {
" int64"
} else {
""
};
out.push_str(&format!("func {}({}){} {{\n", name, params.join(", "), ret));
for stmt in stmts {
match stmt {
Stmt::MutateState(assigns) => {
for a in assigns {
out.push('\t');
out.push_str(&render_assign(a));
out.push('\n');
}
}
Stmt::Assign(a) => {
if analysis.scalar_out.as_deref() == Some(target_var(&a.target)) {
out.push_str(&format!(
"\t{} := {}\n",
target_var(&a.target),
render_expr(&a.value)
));
} else {
out.push('\t');
out.push_str(&render_assign(a));
out.push('\n');
}
}
Stmt::Let(lb) => {
let ty = render_type_go(&lb.ty.clone().unwrap_or(Type::int()));
out.push_str(&format!(
"\t{} := {}({})\n",
lb.name,
ty,
render_expr(&lb.value)
));
}
Stmt::If(is) => {
out.push_str(&format!("\tif {} {{\n", render_expr(&is.condition)));
for s in &is.then_body {
render_go_stmt_indented(s, &mut out, 2);
}
if let Some(else_body) = &is.else_body {
out.push_str("\t} else {\n");
for s in else_body {
render_go_stmt_indented(s, &mut out, 2);
}
}
out.push_str("\t}\n");
}
Stmt::Match(ms) => {
out.push_str(&format!("\tswitch {} {{\n", render_expr(&ms.scrutinee)));
for arm in &ms.arms {
out.push_str(&format!("\tcase {}:\n", render_go_pattern(&arm.pattern)));
for s in &arm.body {
render_go_stmt_indented(s, &mut out, 2);
}
}
out.push_str("\t}\n");
}
Stmt::Return(e) => match e {
Some(expr) => out.push_str(&format!("\treturn {}\n", render_expr(expr))),
None => out.push_str("\treturn\n"),
},
}
}
if let Some(outvar) = &analysis.scalar_out {
out.push_str(&format!("\treturn {}\n", outvar));
}
out.push_str("}\n");
out
}
pub(crate) fn target_var(e: &Expr) -> &str {
match e {
Expr::Var(v) => v,
_ => "",
}
}
pub(crate) fn render_assign(a: &Assign) -> String {
let lhs = render_expr(&a.target);
let rhs = render_expr(&a.value);
let op = match a.op {
AssignOp::Set => "=",
AssignOp::Add => "+=",
AssignOp::Sub => "-=",
};
format!("{} {} {}", lhs, op, rhs)
}
pub(crate) fn render_expr(e: &Expr) -> String {
match e {
Expr::Int(n) => n.to_string(),
Expr::Var(v) => v.clone(),
Expr::Field { base, field } => format!("{}.{}", base, exported(field)),
Expr::Old(inner) => render_expr(inner),
Expr::Unary { op, expr } => match op {
UnOp::Neg => format!("-{}", render_expr(expr)),
},
Expr::Bin { op, lhs, rhs } => {
format!("{} {} {}", render_expr(lhs), bin_op(*op), render_expr(rhs))
}
Expr::Call(c) => {
let args: Vec<_> = c.args.iter().map(render_expr).collect();
format!("{}({})", exported(&c.func), args.join(", "))
}
Expr::MethodCall(m) => {
let args: Vec<_> = m.args.iter().map(render_expr).collect();
format!(
"{}.{}({})",
render_expr(&m.receiver),
exported(&m.method),
args.join(", ")
)
}
Expr::Index(i) => {
format!("{}[{}]", render_expr(&i.receiver), render_expr(&i.index))
}
Expr::If(i) => {
format!(
"(func() int64 {{ if {} {{ return {} }} return {} }})()",
render_expr(&i.condition),
render_expr(&i.then_expr),
render_expr(&i.else_expr)
)
}
Expr::Try(e) => {
match &**e {
Expr::Call(c) => {
let args: Vec<_> = c.args.iter().map(render_expr).collect();
format!(
"(func() int64 {{ v, err := {}({}); if err != nil {{ panic(err) }}; return v }})()",
exported(&c.func),
args.join(", ")
)
}
Expr::MethodCall(m) => {
let args: Vec<_> = m.args.iter().map(render_expr).collect();
format!(
"(func() int64 {{ v, err := {}.{}({}); if err != nil {{ panic(err) }}; return v }})()",
render_expr(&m.receiver),
exported(&m.method),
args.join(", ")
)
}
_ => "(func() int64 { panic(\"try on non-call\") })()".to_string(),
}
}
Expr::Forall(f) => {
format!("/* forall {}: {} */", f.var, render_type_go(&f.var_ty))
}
Expr::Aggregate(a) => {
let args: Vec<_> = a.args.iter().map(render_expr).collect();
format!("/* {}({}) */", a.op.op_name(), args.join(", "))
}
other => format!("/* unsupported: {} */", crate::render_expr(other)),
}
}
fn render_inv(e: &Expr, recv: &str) -> String {
match e {
Expr::Int(n) => n.to_string(),
Expr::Var(v) => format!("{}.{}", recv, exported(v)),
Expr::Field { field, .. } => format!("{}.{}", recv, exported(field)),
Expr::Old(inner) => render_inv(inner, recv),
Expr::Unary { op, expr } => match op {
UnOp::Neg => format!("-{}", render_inv(expr, recv)),
},
Expr::Bin { op, lhs, rhs } => format!(
"{} {} {}",
render_inv(lhs, recv),
bin_op(*op),
render_inv(rhs, recv)
),
other => render_expr(other),
}
}
pub(crate) fn bin_op(op: BinOp) -> &'static str {
match op {
BinOp::Add => "+",
BinOp::Sub => "-",
BinOp::Mul => "*",
BinOp::Div => "/",
BinOp::Eq => "==",
BinOp::Ne => "!=",
BinOp::Lt => "<",
BinOp::Le => "<=",
BinOp::Gt => ">",
BinOp::Ge => ">=",
BinOp::And => "&&",
BinOp::Or => "||",
}
}
pub(crate) fn render_type_go(t: &Type) -> String {
match t {
Type::Named(s) => match s.as_str() {
"Float32" => "float32".to_string(),
"Float64" => "float64".to_string(),
"Int" => "int64".to_string(),
"PositiveInt" => "int64".to_string(),
other => other.to_string(),
},
Type::Generic(name, args) => {
let args: Vec<_> = args.iter().map(render_type_go).collect();
format!("{}<{}>", name, args.join(", "))
}
Type::Tuple(elems) => {
let elems: Vec<_> = elems.iter().map(render_type_go).collect();
format!("({})", elems.join(", "))
}
Type::Array(elem, len) => format!("[{}]{}", len, render_type_go(elem)),
Type::Slice(elem) => format!("[]{}", render_type_go(elem)),
}
}
fn render_go_stmt_indented(s: &Stmt, out: &mut String, indent: usize) {
let prefix = "\t".repeat(indent);
match s {
Stmt::MutateState(assigns) => {
for a in assigns {
out.push_str(&format!("{}{}\n", prefix, render_assign(a)));
}
}
Stmt::Assign(a) => {
out.push_str(&format!("{}{}\n", prefix, render_assign(a)));
}
Stmt::Let(lb) => {
let ty = render_type_go(&lb.ty.clone().unwrap_or(Type::int()));
out.push_str(&format!(
"{}{} := {}({})\n",
prefix,
lb.name,
ty,
render_expr(&lb.value)
));
}
Stmt::If(is) => {
out.push_str(&format!("{}if {} {{\n", prefix, render_expr(&is.condition)));
for s in &is.then_body {
render_go_stmt_indented(s, out, indent + 1);
}
if let Some(else_body) = &is.else_body {
out.push_str(&format!("{}}} else {{\n", prefix));
for s in else_body {
render_go_stmt_indented(s, out, indent + 1);
}
}
out.push_str(&format!("{}}}\n", prefix));
}
Stmt::Match(ms) => {
out.push_str(&format!(
"{}switch {} {{\n",
prefix,
render_expr(&ms.scrutinee)
));
for arm in &ms.arms {
out.push_str(&format!(
"{}case {}:\n",
prefix,
render_go_pattern(&arm.pattern)
));
for s in &arm.body {
render_go_stmt_indented(s, out, indent + 1);
}
}
out.push_str(&format!("{}}}\n", prefix));
}
Stmt::Return(e) => match e {
Some(expr) => out.push_str(&format!("{}return {}\n", prefix, render_expr(expr))),
None => out.push_str(&format!("{}return\n", prefix)),
},
}
}
fn render_go_pattern(p: &Pattern) -> String {
match p {
Pattern::Literal(n) => n.to_string(),
Pattern::Var(v) => v.clone(),
Pattern::Constructor(name, fields) => {
if fields.is_empty() {
exported(name)
} else {
let fs: Vec<_> = fields.iter().map(render_go_pattern).collect();
format!("{}({})", exported(name), fs.join(", "))
}
}
Pattern::Wildcard => "_".to_string(),
}
}