def visit_EUnaryOp(self, e):
op = e.op
if op == UOp.Distinct:
return self.visit_iterable(e)
elif op == UOp.The:
return self.find_one(e.e)
elif op == UOp.Sum:
sum_var = fresh_var(e.type, "sum")
loop_var = fresh_var(e.e.type.elem_type, "x")
self.stms.append(simplify_and_optimize(seq([
SDecl(sum_var, ENum(0).with_type(e.type)),
SForEach(loop_var, e.e,
SAssign(sum_var, EBinOp(sum_var, "+", loop_var).with_type(INT)))])))
return sum_var
elif op == UOp.Length:
arg = EVar("x").with_type(e.e.type.elem_type)
return self.visit(EUnaryOp(UOp.Sum, EMap(e.e, ELambda(arg, ONE)).with_type(INT_BAG)).with_type(INT))
elif op == UOp.All:
arg = EVar("x").with_type(e.e.type.elem_type)
return self.visit(EUnaryOp(UOp.Empty, EFilter(e.e, ELambda(arg, ENot(arg))).with_type(INT_BAG)).with_type(INT))
elif op == UOp.Any:
arg = EVar("x").with_type(e.e.type.elem_type)
return self.visit(EUnaryOp(UOp.Exists, EFilter(e.e, ELambda(arg, arg)).with_type(INT_BAG)).with_type(INT))
elif op == UOp.Empty:
iterable = e.e
v = fresh_var(BOOL, "v")
label = fresh_name("label")
x = fresh_var(iterable.type.elem_type, "x")
decl = SDecl(v, ETRUE)
find = SEscapableBlock(label,
SForEach(x, iterable, seq([
SAssign(v, EFALSE),
SEscapeBlock(label)])))
self.stms.append(simplify_and_optimize(seq([decl, find])))
return v
elif op == UOp.Exists:
return self.visit(ENot(EUnaryOp(UOp.Empty, e.e).with_type(BOOL)))
# elif op == UOp.AreUnique:
# s = fresh_var(TSet(e.e.type.elem_type), "unique_elems")
# u = fresh_var(BOOL, "is_unique")
# x = fresh_var(e.e.type.elem_type)
# label = fresh_name("label")
# self.visit(seq([
# SDecl(s, EEmptyList().with_type(s.type)),
# SDecl(u, ETRUE),
# SEscapableBlock(label,
# SForEach(x, e.e,
# SIf(EEscape("{s}.find({x}) != {s}.end()", ("s", "x"), (s, x)).with_type(BOOL),
# seq([SAssign(u, EFALSE), SEscapeBlock(label)]),
# SEscape("{indent}{s}.insert({x});\n", ("s", "x"), (s, x)))))]))
# return u.id
return self.visit_Exp(e)
def mutate_in_place(self, lval, e, op, assumptions, make_subgoal):
from cozy.state_maintenance import mutate
old_value = e
new_value = mutate(e, op)
# added/removed elements
t = TBag(lval.type.elem_type)
old_elems = EHeapElems(old_value).with_type(t)
new_elems = EHeapElems(new_value).with_type(t)
initial_count = make_subgoal(ELen(old_elems))
to_add = make_subgoal(EBinOp(new_elems, "-", old_elems).with_type(t), docstring="additions to {}".format(pprint(lval)))
to_del_spec = EBinOp(old_elems, "-", new_elems).with_type(t)
removed_count = make_subgoal(ELen(to_del_spec))
to_del = make_subgoal(to_del_spec, docstring="deletions from {}".format(pprint(lval)))
# modified elements
f1 = heap_func(old_value)
f2 = heap_func(new_value)
v = fresh_var(t.t)
old_v_key = f1.apply_to(v)
new_v_key = f2.apply_to(v)
mod_spec = EFilter(old_elems, ELambda(v, EAll([EIn(v, new_elems), ENot(EEq(new_v_key, old_v_key))]))).with_type(new_elems.type)
modified = make_subgoal(mod_spec)
return seq([
SCall(lval, "remove_all", (initial_count, to_del)),
SCall(lval, "add_all", (EBinOp(initial_count, "-", removed_count).with_type(INT), to_add)),
SForEach(v, modified, SCall(lval, "update", (v, make_subgoal(new_v_key, a=[EIn(v, mod_spec)]))))])
def _setup_handle_updates(self):
"""
This method creates update code for handle objects modified by each op.
Must be called once after all user-specified queries have been added.
"""
for op in self.op_specs:
print("Setting up handle updates for {}...".format(op.name))
handles = reachable_handles_at_method(self.spec, op)
# print("-"*60)
for t, bag in handles.items():
# print(" {} : {}".format(pprint(t), pprint(bag)))
h = fresh_var(t)
lval = EGetField(h, "val").with_type(t.value_type)
new_val = inc.mutate(lval, op.body)
# get set of modified handles
modified_handles = Query(
fresh_name("modified_handles"), Visibility.Internal, [],
op.assumptions,
EFilter(
EUnaryOp(UOp.Distinct, bag).with_type(bag.type),
ELambda(h, ENot(EEq(lval,
new_val)))).with_type(bag.type),
"[{}] modified handles of type {}".format(
op.name, pprint(t)))
query_vars = [
v for v in free_vars(modified_handles)
if v not in self.abstract_state
]
modified_handles.args = [(arg.id, arg.type)
for arg in query_vars]
# modify each one
subqueries = []
state_update_stm = inc.mutate_in_place(
lval,
lval,
op.body,
abstract_state=self.abstract_state,
assumptions=list(op.assumptions) +
[EDeepIn(h, bag),
EIn(h, modified_handles.ret)],
invariants=self.abstract_invariants,
subgoals_out=subqueries)
for sub_q in subqueries:
sub_q.docstring = "[{}] {}".format(op.name,
sub_q.docstring)
state_update_stm = self._add_subquery(
sub_q=sub_q, used_by=state_update_stm)
if state_update_stm != SNoOp():
state_update_stm = SForEach(
h,
ECall(modified_handles.name,
query_vars).with_type(bag.type),
state_update_stm)
state_update_stm = self._add_subquery(
sub_q=modified_handles, used_by=state_update_stm)
self.handle_updates[(t, op.name)] = state_update_stm
def _setup_handle_updates(self):
"""
This method creates update code for handle objects modified by each op.
Must be called once after all user-specified queries have been added.
"""
for op in self.op_specs:
handles = reachable_handles_at_method(self.spec, op)
# print("-"*60)
for t, bag in handles.items():
# print(" {} : {}".format(pprint(t), pprint(bag)))
h = fresh_var(t)
delta = inc.delta_form(
self.spec.statevars + op.args + [(h.id, h.type)], op)
lval = EGetField(h, "val").with_type(t.value_type)
new_val = simplify(subst(lval, delta))
# get set of modified handles
modified_handles = Query(
fresh_name("modified_handles"), Visibility.Internal, [],
op.assumptions,
EFilter(
EUnaryOp(UOp.Distinct, bag).with_type(bag.type),
ELambda(h, ENot(EEq(lval,
new_val)))).with_type(bag.type),
"[{}] modified handles of type {}".format(
op.name, pprint(t)))
query_vars = [
v for v in free_vars(modified_handles)
if v not in self.abstract_state
]
modified_handles.args = [(arg.id, arg.type)
for arg in query_vars]
# modify each one
(state_update_stm, subqueries) = inc.sketch_update(
lval, lval, new_val, self.abstract_state,
list(op.assumptions) +
[EDeepIn(h, bag),
EIn(h, modified_handles.ret)])
# print(" got {} subqueries".format(len(subqueries)))
# print(" to update {} in {}, use\n{}".format(pprint(t), op.name, pprint(state_update_stm)))
for sub_q in subqueries:
sub_q.docstring = "[{}] {}".format(op.name,
sub_q.docstring)
state_update_stm = self._add_subquery(
sub_q=sub_q, used_by=state_update_stm)
if state_update_stm != SNoOp():
state_update_stm = SForEach(
h,
ECall(modified_handles.name,
query_vars).with_type(bag.type),
state_update_stm)
state_update_stm = self._add_subquery(
sub_q=modified_handles, used_by=state_update_stm)
self.handle_updates[(t, op.name)] = state_update_stm
def maintenance_cost(self,
old_value: Exp,
new_value: Exp,
op: Op,
storage_size,
maintenance_cost,
freebies: [Exp] = []):
assert type(e.type) in (TMinHeap, TMaxHeap)
# added/removed elements
t = TBag(e.type.elem_type)
old_elems = EHeapElems(old_value).with_type(t)
new_elems = EHeapElems(new_value).with_type(t)
# Add these
elems_added = storage_size(
EBinOp(new_elems, "-", old_elems).with_type(t),
freebies).with_type(INT)
elems_rmved = storage_size(
EBinOp(old_elems, "-", new_elems).with_type(t),
freebies).with_type(INT)
# modified elements
f1 = heap_func(old_value)
f2 = heap_func(new_value)
v = fresh_var(t.t)
old_v_key = f1.apply_to(v)
new_v_key = f2.apply_to(v)
modified_elems = EFilter(
old_elems,
ELambda(v,
EAll([EIn(v, new_elems),
ENot(EEq(new_v_key,
old_v_key))]))).with_type(new_elems.type)
modified_cost = EUnaryOp(
UOp.Sum,
EMap(
modified_elems,
ELambda(v,
maintenance_cost(new_v_key, op, freebies)).with_type(
INT)).with_type(INT)).with_type(INT_BAG)
return ESum([elems_added, elems_rmved, modified_cost])
def possibly_useful_nonrecursive(
solver,
e: Exp,
context: Context,
pool=RUNTIME_POOL,
assumptions: Exp = ETRUE,
ops: [Op] = ()) -> bool:
"""Heuristic filter to ignore expressions that are almost certainly useless."""
state_vars = OrderedSet(v for v, p in context.vars() if p == STATE_POOL)
args = OrderedSet(v for v, p in context.vars() if p == RUNTIME_POOL)
assumptions = EAll([assumptions, context.path_condition()])
at_runtime = pool == RUNTIME_POOL
h = extension_handler(type(e))
if h is not None:
res = h.possibly_useful(e, context, pool, assumptions, ops, solver)
if not res:
return res
if isinstance(e, EStateVar) and not free_vars(e.e):
return No("constant value in state position")
if (isinstance(e, EDropFront)
or isinstance(e, EDropBack)) and not at_runtime:
return No("EDrop* in state position")
if not allow_big_sets.value and isinstance(e, EFlatMap) and not at_runtime:
return No("EFlatMap in state position")
if not allow_int_arithmetic_state.value and not at_runtime and isinstance(
e, EBinOp) and e.type == INT:
return No("integer arithmetic in state position")
if is_collection(e.type) and not is_scalar(e.type.elem_type):
return No("collection of nonscalar: e {}\n elem_type: {}\n".format(
e, e.type.elem_type))
if isinstance(e.type, TMap) and not is_scalar(e.type.k):
return No("bad key type {}".format(pprint(e.type.k)))
if isinstance(e.type, TMap) and isinstance(e.type.v, TMap):
return No("map to map")
# This check is probably a bad idea: whether `the` is legal may depend on
# the contex that the expression is embedded within, so we can't skip it
# during synthesis just because it looks invalid now.
# if isinstance(e, EUnaryOp) and e.op == UOp.The:
# len = EUnaryOp(UOp.Length, e.e).with_type(INT)
# if not valid(EImplies(assumptions, EBinOp(len, "<=", ENum(1).with_type(INT)).with_type(BOOL))):
# return No("illegal application of 'the': could have >1 elems")
if not at_runtime and isinstance(
e, EBinOp) and e.op == "-" and is_collection(e.type):
return No("collection subtraction in state position")
# if not at_runtime and isinstance(e, ESingleton):
# return No("singleton in state position")
if not allow_nonzero_state_constants.value and not at_runtime and isinstance(
e, ENum) and e.val != 0:
return No("nonzero integer constant in state position")
if not allow_binop_state.value and at_runtime and isinstance(
e, EStateVar) and isinstance(e.e, EBinOp) and is_scalar(
e.e.e1.type) and is_scalar(e.e.e2.type):
return No(
"constant-time binary operator {!r} in state position".format(
e.e.op))
if not allow_conditional_state.value and not at_runtime and isinstance(
e, ECond):
return No("conditional in state position")
if isinstance(e, EMakeMap2) and isinstance(e.e, EEmptyList):
return No("trivially empty map")
if isinstance(e, EMakeMap2) and isinstance(e.e, ESingleton):
return No("really tiny map")
if not at_runtime and (isinstance(e, EArgMin) or isinstance(e, EArgMax)):
# Cozy has no way to efficiently implement mins/maxes when more than
# one element may leave the collection.
from cozy.state_maintenance import mutate
for op in ops:
elems = e.e
elems_prime = mutate(elems, op.body)
formula = EAll([assumptions] + list(op.assumptions) + [
EGt(
ELen(
EBinOp(elems, "-", elems_prime).with_type(elems.type)),
ONE)
])
if solver.satisfiable(formula):
return No(
"more than one element might be removed during {}".format(
op.name))
if not allow_peels.value and not at_runtime and isinstance(e, EFilter):
# catch "peels": removal of zero or one elements
if solver.valid(
EImplies(
assumptions,
ELe(
ELen(
EFilter(
e.e,
ELambda(e.predicate.arg, ENot(
e.predicate.body))).with_type(e.type)),
ONE))):
return No("filter is a peel")
if not allow_big_maps.value and not at_runtime and isinstance(
e, EMakeMap2) and is_collection(e.type.v):
all_collections = [sv for sv in state_vars if is_collection(sv.type)]
total_size = ENum(0).with_type(INT)
for c in all_collections:
total_size = EBinOp(total_size, "+",
EUnaryOp(UOp.Length,
c).with_type(INT)).with_type(INT)
my_size = EUnaryOp(
UOp.Length,
EFlatMap(
EUnaryOp(UOp.Distinct, e.e).with_type(e.e.type),
e.value_function).with_type(e.type.v)).with_type(INT)
s = EImplies(assumptions,
EBinOp(total_size, ">=", my_size).with_type(BOOL))
if not solver.valid(s):
return No("non-polynomial-sized map")
return True
def _enumerate_core(self, context: Context, size: int,
pool: Pool) -> [Exp]:
"""Build new expressions of the given size.
Arguments:
context : a Context object describing the vars in scope
size : size of expressions to enumerate; each expression in
the output will have this size
pool : pool to enumerate
This function is not cached. Clients should call `enumerate` instead.
This function tries to be a clean description of the Cozy grammar. It
does not concern itself with deduplication (which is handled
efficiently by equivalence class deduplication).
"""
if size < 0:
return
if size == 0:
for e in LITERALS:
yield e
all_interesting_types = OrderedSet(self.hint_types)
for v, _ in context.vars():
all_interesting_types |= all_types(v.type)
for t in all_interesting_types:
l = construct_value(t)
if l not in LITERALS:
yield l
for (v, p) in context.vars():
if p == pool:
yield v
for (e, ctx, p) in self.hints:
if p == pool:
fvs = free_vars(e)
if ctx.alpha_equivalent(context.generalize(fvs)):
yield context.adapt(e, ctx, e_fvs=fvs)
return
if not do_enumerate.value:
return
def build_lambdas(bag, pool, body_size):
v = fresh_var(bag.type.elem_type,
omit=set(v for v, p in context.vars()))
inner_context = UnderBinder(context, v=v, bag=bag, bag_pool=pool)
for lam_body in self.enumerate(inner_context, body_size, pool):
yield ELambda(v, lam_body)
# Load all smaller expressions in this context and pool.
# cache[S] contains expressions of size S in this context and pool.
cache = [list(self.enumerate(context, sz, pool)) for sz in range(size)]
# Enable use of a state-pool expression at runtime
if pool == RUNTIME_POOL:
for e in self.enumerate(context.root(), size - 1, STATE_POOL):
yield EStateVar(e).with_type(e.type)
# Arity-1 expressions
for e in cache[size - 1]:
if is_collection(e.type):
elem_type = e.type.elem_type
# This method of generating EEmptyList() ensures that we visit
# empty collections of all possible types.
yield EEmptyList().with_type(e.type)
if is_numeric(elem_type):
yield EUnaryOp(UOp.Sum, e).with_type(elem_type)
yield EUnaryOp(UOp.Length, e).with_type(INT)
yield EUnaryOp(UOp.Empty, e).with_type(BOOL)
yield EUnaryOp(UOp.Exists, e).with_type(BOOL)
yield EUnaryOp(UOp.The, e).with_type(elem_type)
yield EUnaryOp(UOp.Distinct, e).with_type(e.type)
yield EUnaryOp(UOp.AreUnique, e).with_type(BOOL)
if elem_type == BOOL:
yield EUnaryOp(UOp.Any, e).with_type(BOOL)
yield EUnaryOp(UOp.All, e).with_type(BOOL)
yield ESingleton(e).with_type(TBag(e.type))
if isinstance(e.type, TRecord):
for (f, t) in e.type.fields:
yield EGetField(e, f).with_type(t)
if isinstance(e.type, THandle):
yield EGetField(e, "val").with_type(e.type.value_type)
if isinstance(e.type, TTuple):
for n in range(len(e.type.ts)):
yield ETupleGet(e, n).with_type(e.type.ts[n])
if e.type == BOOL:
yield EUnaryOp(UOp.Not, e).with_type(BOOL)
if is_numeric(e.type):
yield EUnaryOp("-", e).with_type(e.type)
if isinstance(e.type, TMap):
yield EMapKeys(e).with_type(TBag(e.type.k))
# Arity-2 expressions
for (sz1, sz2) in pick_to_sum(2, size - 1):
# sz1 + sz2 = size - 1
for e1 in cache[sz1]:
t = e1.type
if is_numeric(t):
for a2 in of_type(cache[sz2], t):
yield EBinOp(e1, "+", a2).with_type(t)
yield EBinOp(e1, "-", a2).with_type(t)
if is_ordered(t):
for a2 in of_type(cache[sz2], t):
yield EBinOp(e1, ">", a2).with_type(BOOL)
yield EBinOp(e1, "<", a2).with_type(BOOL)
yield EBinOp(e1, ">=", a2).with_type(BOOL)
yield EBinOp(e1, "<=", a2).with_type(BOOL)
if t == BOOL:
for a2 in of_type(cache[sz2], BOOL):
yield EBinOp(e1, BOp.And, a2).with_type(BOOL)
yield EBinOp(e1, BOp.Or, a2).with_type(BOOL)
# Cozy supports the implication operator "=>", but this
# function does not enumerate it because
# - (a => b) is equivalent to ((not a) or b)
# - there isn't an implication operator in any of our
# current target languages, so we would need to
# desugar it to ((not a) or b) anyway.
if not isinstance(t, TMap):
for a2 in of_type(cache[sz2], t):
yield EEq(e1, a2)
yield EBinOp(e1, "!=", a2).with_type(BOOL)
if isinstance(t, TMap):
for k in of_type(cache[sz2], t.k):
yield EMapGet(e1, k).with_type(t.v)
yield EHasKey(e1, k).with_type(BOOL)
if isinstance(t, TList):
for i in of_type(cache[sz2], INT):
yield EListGet(e1, i).with_type(e1.type.elem_type)
if is_collection(t):
elem_type = t.elem_type
for e2 in of_type(cache[sz2], t):
yield EBinOp(e1, "+", e2).with_type(t)
yield EBinOp(e1, "-", e2).with_type(t)
for e2 in of_type(cache[sz2], elem_type):
yield EBinOp(e2, BOp.In, e1).with_type(BOOL)
for f in build_lambdas(e1, pool, sz2):
body_type = f.body.type
yield EMap(e1, f).with_type(TBag(body_type))
if body_type == BOOL:
yield EFilter(e1, f).with_type(t)
if is_numeric(body_type):
yield EArgMin(e1, f).with_type(elem_type)
yield EArgMax(e1, f).with_type(elem_type)
if is_collection(body_type):
yield EFlatMap(e1, f).with_type(
TBag(body_type.elem_type))
if pool == STATE_POOL and is_hashable(elem_type):
yield EMakeMap2(e1, f).with_type(
TMap(elem_type, body_type))
e1_singleton = ESingleton(e1).with_type(TBag(e1.type))
for f in build_lambdas(e1_singleton, pool, sz2):
yield ELet(e1, f).with_type(f.body.type)
# Arity-3 expressions
for (sz1, sz2, sz3) in pick_to_sum(3, size - 1):
# sz1 + sz2 + sz3 = size - 1
for e1 in cache[sz1]:
if e1.type == BOOL:
cond = e1
for then_branch in cache[sz2]:
for else_branch in of_type(cache[sz3],
then_branch.type):
yield ECond(cond, then_branch,
else_branch).with_type(
then_branch.type)
if isinstance(e1.type, TList):
for start in of_type(cache[sz2], INT):
for end in of_type(cache[sz3], INT):
yield EListSlice(e1, start, end).with_type(e1.type)
# It is not necessary to create slice expressions of
# the form a[:i] or a[i:]. Those are desugared
# after parsing to a[0:i] and a[i:len(a)]
# respectively, and Cozy is perfectly capable of
# discovering these expanded forms as well.
for h in all_extension_handlers():
yield from h.enumerate(context, size, pool, self.enumerate,
build_lambdas)