use super::{ParseError, ParseErrorKind, ParseResult, Parser};
use crate::ast::*;
use crate::lexer::{Span, TokenKind};
pub const REQUIRES_PREFIX: &str = "__bl_requires__";
pub const ENSURES_PREFIX: &str = "__bl_ensures__";
pub const LAW_ATTR: &str = "law";
#[derive(Default)]
pub(super) struct Clauses {
pub requires: Vec<Expr>,
pub ensures: Vec<Expr>,
}
impl<'a> Parser<'a> {
pub(super) fn at_word(&self, word: &str) -> bool {
matches!(self.current_kind(), TokenKind::Ident)
&& self.source.slice(self.current_span()) == word
}
pub(super) fn at_law_decl(&self) -> bool {
self.at_word("law") && matches!(self.peek().kind, TokenKind::Ident)
}
pub(super) fn parse_contract_clauses(&mut self) -> ParseResult<Clauses> {
let mut clauses = Clauses::default();
loop {
let is_requires = self.at_word("requires");
if !is_requires && !self.at_word("ensures") {
return Ok(clauses);
}
self.advance();
let saved = self.restrictions;
self.restrictions.no_struct_literal = true;
let expr = self.parse_expr();
self.restrictions = saved;
let expr = expr?;
if is_requires {
clauses.requires.push(expr);
} else {
clauses.ensures.push(expr);
}
}
}
pub(super) fn parse_law(
&mut self,
mut attrs: Vec<Attribute>,
vis: Visibility,
start: Span,
) -> ParseResult<Item> {
let law_span = self.current_span();
self.advance(); let mut fn_def = self.parse_fn_after_keyword(false, false, false)?;
if fn_def.sig.return_ty.is_some() {
return Err(ParseError::new(
ParseErrorKind::Expected {
expected: "a law body without a return type (a law returns bool)".into(),
found: "`->`".into(),
},
law_span,
));
}
if fn_def.body.is_none() {
return Err(self.error_expected("a law body `{ .. }`"));
}
fn_def.sig.return_ty = Some(Box::new(named_type("bool", law_span)));
attrs.push(Attribute {
path: Path::from_ident(Ident::new(LAW_ATTR, law_span)),
args: AttrArgs::Empty,
is_inner: false,
span: law_span,
});
let span = start.merge(&self.tokens[self.pos.saturating_sub(1)].span);
Ok(Item::new(
ItemKind::Function(Box::new(fn_def)),
vis,
attrs,
span,
))
}
pub(super) fn queue_contract_items(&mut self, fn_def: &FnDef, clauses: Clauses) {
let span = fn_def.name.span;
let has_self = fn_def.sig.params.iter().any(
|p| matches!(&p.pattern.kind, PatternKind::Ident { name, .. } if &*name.name == "self"),
);
if has_self || !fn_def.generics.params.is_empty() {
self.errors.push(ParseError::new(
ParseErrorKind::Expected {
expected: "requires/ensures on a free, non-generic function".into(),
found: "a method or a generic function".into(),
},
span,
));
return;
}
let base = &fn_def.name.name;
if let Some(req) = conjoin(clauses.requires) {
let params = fn_def.sig.params.clone();
let name = format!("{REQUIRES_PREFIX}{base}");
self.pending_items.push(spec_fn(&name, params, req, span));
}
if let Some(ens) = conjoin(clauses.ensures) {
let mut params = fn_def.sig.params.clone();
let ret = fn_def
.sig
.return_ty
.clone()
.unwrap_or_else(|| Box::new(Type::new(TypeKind::Tuple(Vec::new()), span)));
params.push(Param {
attrs: Vec::new(),
pattern: Pattern::new(
PatternKind::Ident {
mutability: Mutability::Immutable,
name: Ident::new("result", span),
subpattern: None,
},
span,
),
ty: ret,
default: None,
span,
});
let name = format!("{ENSURES_PREFIX}{base}");
self.pending_items.push(spec_fn(&name, params, ens, span));
}
}
pub(super) fn drain_pending_items(&mut self, items: &mut Vec<Item>) {
items.append(&mut self.pending_items);
}
}
fn named_type(name: &str, span: Span) -> Type {
Type::new(
TypeKind::Path(Path::from_ident(Ident::new(name, span))),
span,
)
}
fn conjoin(mut exprs: Vec<Expr>) -> Option<Expr> {
if exprs.is_empty() {
return None;
}
let mut acc = exprs.remove(0);
for e in exprs {
let span = acc.span.merge(&e.span);
acc = Expr::new(
ExprKind::Binary {
op: BinOp::And,
left: Box::new(acc),
right: Box::new(e),
},
span,
);
}
Some(acc)
}
fn spec_fn(name: &str, params: Vec<Param>, body: Expr, span: Span) -> Item {
let body_span = body.span;
let block = Block::new(
vec![crate::ast::Stmt::new(
StmtKind::Expr(Box::new(body)),
body_span,
)],
body_span,
);
let def = FnDef {
name: Ident::new(name, span),
generics: Generics::default(),
sig: FnSig {
params,
return_ty: Some(Box::new(named_type("bool", span))),
..FnSig::default()
},
body: Some(Box::new(block)),
};
Item::new(
ItemKind::Function(Box::new(def)),
Visibility::Private,
Vec::new(),
span,
)
}