/// <summary>
/// Initialize a new tactic state
/// </summary>
/// <param name="tacAps">Tactic application</param>
/// <param name="variables">Dafny variables</param>
public void InitState(UpdateStmt tacAps, Dictionary<IVariable, Dfy.Type> variables) {
// clear the scope
_scope = new Stack<Frame>();
var tactic = GetTactic(tacAps) as Tactic;
var aps = ((ExprRhs)tacAps.Rhss[0]).Expr as ApplySuffix;
if(aps.Args.Count != tactic.Ins.Count)
Reporter.Error(MessageSource.Tacny, tacAps.Tok,
$"Wrong number of method arguments (got {aps.Args.Count}, expected {tactic.Ins.Count})");
var frame = new Frame(tactic, Reporter);
foreach(var item in variables) {
if(!frame.ContainDafnyVar(item.Key.Name))
frame.AddDafnyVar(item.Key.Name, new VariableData { Variable = item.Key, Type = item.Value });
else
throw new ArgumentException($"Dafny variable {item.Key.Name} is already declared in the current context");
}
for(int index = 0; index < aps.Args.Count; index++) {
var arg = aps.Args[index];
frame.AddTacnyVar(tactic.Ins[index].Name, arg);
}
_scope.Push(frame);
TacticApplication = tacAps.Copy();
}
public TacticErrorReportingResolver(Tacny.CompoundErrorInformation errorInfo)
{
Contract.Ensures(_errTok != null);
Contract.Ensures(_errMessage != null);
Contract.Ensures(_tacticCall != null);
Contract.Ensures(_activeTactic != null);
Contract.Ensures(_callingMember != null);
Contract.Ensures(_tmpFailingMember != null);
Contract.Ensures(!string.IsNullOrEmpty(_implTargetName));
var proofState = errorInfo.S;
var tmpProgram = ((Tacny.CompoundErrorInformation)errorInfo.E).P;
var innerError = ((Tacny.CompoundErrorInformation)errorInfo.E).E;
var tmpModule = (DefaultClassDecl)tmpProgram.DefaultModuleDef.TopLevelDecls.FirstOrDefault();
_errTok = (Bpl.Token)innerError.Tok;
_errMessage = innerError.FullMsg;
_implTargetName = MethodNameFromImpl(innerError.ImplementationName);
_tacticCall = proofState.TacticApplication;
_activeTactic = proofState.GetTactic(_tacticCall) as Tactic;
_callingMember = proofState.TargetMethod;
_tmpFailingMember = tmpModule?.Members.FirstOrDefault(x => x.CompileName == _implTargetName);
FailingLine = FailingCol = TacticLine = TacticCol = CallingLine = CallingCol = -1;
if(!ActiveTacticWasNotUsed()) ResolveCorrectLocations();
}
public DynamicContext(MemberDecl md, ITactic tac, UpdateStmt tac_call)
: base(md, tac_call) {
tactic = tac;
if (tactic is Tactic) {
var tmp = tactic as Tactic;
tacticBody = new List<Statement>(tmp.Body.Body.ToArray());
}
tacCounter = 0;
FillTacticInputs();
}
public static List<Statement> FindSingleTactic(Program program, MemberDecl target,
UpdateStmt chosenTacticCall, ErrorReporterDelegate erd, Program unresolvedProgram)
{
Contract.Requires(program != null);
Contract.Requires(target != null);
var i = new Interpreter(program, unresolvedProgram);
_errorReporterDelegate = erd;
var list = i.FindSingleTacticApplication(target, chosenTacticCall);
_errorReporterDelegate = null;
return list;
}
/// <summary>
/// Deep copy updateStmt
/// </summary>
/// <param name="stmt"></param>
/// <returns></returns>
public static UpdateStmt CopyUpdateStmt(UpdateStmt stmt) {
ExprRhs old_exp = stmt.Rhss[0] as ExprRhs;
ApplySuffix old_aps = old_exp.Expr as ApplySuffix;
LiteralExpr literal = old_exp.Expr as LiteralExpr;
if (old_aps != null) {
ApplySuffix aps = CopyExpression(old_aps) as ApplySuffix;
return new UpdateStmt(stmt.Tok, stmt.EndTok, CopyExpressionList(stmt.Lhss), new List<AssignmentRhs> { new ExprRhs(aps) });
}
if (literal != null) {
return new UpdateStmt(stmt.Tok, stmt.EndTok, CopyExpressionList(stmt.Lhss), new List<AssignmentRhs> { new ExprRhs(CopyExpression(literal)) });
}
return null;
}
public DynamicContext(MemberDecl md, ITactic tac, UpdateStmt tac_call,
List<Statement> tac_body, Dictionary<IVariable, object> local_variables,
Dictionary<Statement, Statement> updated_statements, int tacCounter, MemberDecl old_target)
: base(md, tac_call) {
tactic = tac;
tacticBody = new List<Statement>(tac_body.ToArray());
List<IVariable> lv_keys = new List<IVariable>(local_variables.Keys);
List<object> lv_values = new List<object>(local_variables.Values);
localDeclarations = lv_keys.ToDictionary(x => x, x => lv_values[lv_keys.IndexOf(x)]);
generatedStatements = updated_statements;
this.tacCounter = tacCounter;
newTarget = old_target;
}
private List<Statement> FindSingleTacticApplication(MemberDecl target, UpdateStmt chosenTacticCall)
{
Contract.Requires(tcce.NonNull(target));
_frame = new Stack<Dictionary<IVariable, Type>>();
var method = target as Method;
if (method == null) return null;
_state.SetTopLevelClass(method.EnclosingClass?.Name);
_state.TargetMethod = target;
var dict = method.Ins.Concat(method.Outs)
.ToDictionary<IVariable, IVariable, Type>(item => item, item => item.Type);
_frame.Push(dict);
SearchBlockStmt(method.Body);
_frame.Pop();
Contract.Assert(_frame.Count == 0);
return (from r in _resultList
where r.Key.Tok.pos == chosenTacticCall.Tok.pos
select r.Value).FirstOrDefault();
}
/// <summary>
/// Initialize a new tactic state
/// </summary>
/// <param name="tacAps">Tactic application</param>
/// <param name="variables">Dafny variables</param>
public void InitState(UpdateStmt tacAps, Dictionary<IVariable, Dfy.Type> variables) {
// clear the scope
_scope = new Stack<Frame>();
var tactic = GetTactic(tacAps) as Tactic;
var aps = ((ExprRhs) tacAps.Rhss[0]).Expr as ApplySuffix;
if (aps.Args.Count != tactic.Ins.Count)
Reporter.Error(MessageSource.Tacny, tacAps.Tok,
$"Wrong number of method arguments (got {aps.Args.Count}, expected {tactic.Ins.Count})");
var frame = new Frame(tactic, Reporter);
for (int index = 0; index < aps.Args.Count; index++) {
var arg = aps.Args[index];
frame.AddLocalVariable(tactic.Ins[index].Name, arg);
}
_scope.Push(frame);
FillSourceState(variables);
TacticApplication = tacAps.Copy();
}
void VarDeclStatement(out Statement/*!*/ s)
{
IToken x = null, assignTok = null; bool isGhost = false;
LocalVariable d;
AssignmentRhs r;
List<LocalVariable> lhss = new List<LocalVariable>();
List<AssignmentRhs> rhss = new List<AssignmentRhs>();
IToken suchThatAssume = null;
Expression suchThat = null;
Attributes attrs = null;
IToken endTok;
if (la.kind == 73) {
Get();
isGhost = true; x = t;
}
Expect(78);
if (!isGhost) { x = t; }
while (la.kind == 46) {
Attribute(ref attrs);
}
LocalIdentTypeOptional(out d, isGhost);
lhss.Add(d); d.Attributes = attrs; attrs = null;
while (la.kind == 22) {
Get();
while (la.kind == 46) {
Attribute(ref attrs);
}
LocalIdentTypeOptional(out d, isGhost);
lhss.Add(d); d.Attributes = attrs; attrs = null;
}
if (la.kind == 25 || la.kind == 46 || la.kind == 95) {
if (la.kind == 95) {
Get();
assignTok = t;
Rhs(out r);
rhss.Add(r);
while (la.kind == 22) {
Get();
Rhs(out r);
rhss.Add(r);
}
} else {
while (la.kind == 46) {
Attribute(ref attrs);
}
Expect(25);
assignTok = t;
if (la.kind == _assume) {
Expect(31);
suchThatAssume = t;
}
Expression(out suchThat, false, true);
}
}
while (!(la.kind == 0 || la.kind == 28)) {SynErr(184); Get();}
Expect(28);
endTok = t;
ConcreteUpdateStatement update;
if (suchThat != null) {
var ies = new List<Expression>();
foreach (var lhs in lhss) {
ies.Add(new IdentifierExpr(lhs.Tok, lhs.Name));
}
update = new AssignSuchThatStmt(assignTok, endTok, ies, suchThat, suchThatAssume, attrs);
} else if (rhss.Count == 0) {
update = null;
} else {
var ies = new List<Expression>();
foreach (var lhs in lhss) {
ies.Add(new AutoGhostIdentifierExpr(lhs.Tok, lhs.Name));
}
update = new UpdateStmt(assignTok, endTok, ies, rhss);
}
s = new VarDeclStmt(x, endTok, lhss, update);
}
private TacticReplaceStatus ExpandSingleTacticCall(UpdateStmt us, out string expanded) {
expanded = "";
var l = Interpreter.GetTacnyResultList();
var result = l.FirstOrDefault(pair => RefactoringUtil.TokenEquals(pair.Key,us.Tok));
if (result.Value == null) return TacticReplaceStatus.NoTactic;
var sr = new StringWriter();
var printer = new Printer(sr);
result.Value.ForEach(stmt => printer.PrintStatement(stmt, 4));
expanded = sr.ToString();
return !string.IsNullOrEmpty(expanded) ? TacticReplaceStatus.Success : TacticReplaceStatus.NoTactic;
}
void UpdateStmt(out Statement/*!*/ s)
{
List<Expression> lhss = new List<Expression>();
List<AssignmentRhs> rhss = new List<AssignmentRhs>();
Expression e; AssignmentRhs r;
IToken x, endTok = Token.NoToken;
Attributes attrs = null;
IToken suchThatAssume = null;
Expression suchThat = null;
Lhs(out e);
x = e.tok;
if (la.kind == 28 || la.kind == 46) {
while (la.kind == 46) {
Attribute(ref attrs);
}
Expect(28);
endTok = t; rhss.Add(new ExprRhs(e, attrs));
} else if (la.kind == 22 || la.kind == 25 || la.kind == 95) {
lhss.Add(e);
while (la.kind == 22) {
Get();
Lhs(out e);
lhss.Add(e);
}
if (la.kind == 95) {
Get();
x = t;
Rhs(out r);
rhss.Add(r);
while (la.kind == 22) {
Get();
Rhs(out r);
rhss.Add(r);
}
} else if (la.kind == 25) {
Get();
x = t;
if (la.kind == _assume) {
Expect(31);
suchThatAssume = t;
}
Expression(out suchThat, false, true);
} else SynErr(182);
Expect(28);
endTok = t;
} else if (la.kind == 21) {
Get();
SemErr(t, "invalid statement (did you forget the 'label' keyword?)");
} else SynErr(183);
if (suchThat != null) {
s = new AssignSuchThatStmt(x, endTok, lhss, suchThat, suchThatAssume, null);
} else {
if (lhss.Count == 0 && rhss.Count == 0) {
s = new BlockStmt(x, endTok, new List<Statement>()); // error, give empty statement
} else {
s = new UpdateStmt(x, endTok, lhss, rhss);
}
}
}
private void FindRemovableTypesInUpdateStmt(UpdateStmt updateStmt, Statement parent, Method method, ClassDecl classDecl)
{
if (parent is BlockStmt) {
var blockStmt = (BlockStmt) parent;
FindRemovableTypesInUpdateStmt(updateStmt, blockStmt.Body, method, classDecl);
}
else if (parent is MatchStmt) {
var matchStmt = (MatchStmt) parent;
foreach (var matchCase in matchStmt.Cases) {
if (!matchCase.Body.Contains(updateStmt)) continue;
FindRemovableTypesInUpdateStmt(updateStmt, matchCase.Body, method, classDecl);
break;
}
}
}
/*
private static IEnumerable<ProofState> ResolveFlowControlStmt(Statement stmt, ProofState state) {
Language.FlowControlStmt fcs = null;
if(stmt is IfStmt) {
//fcs = new Language.IfStmt();
//TODO: if statemenet
} else if(stmt is WhileStmt) {
//TODO: while statemenet
} else {
Contract.Assert(false);
return null;
}
return fcs.Generate(stmt, state);
}
*/
public static IEnumerable<ProofState> EvalTacApp(UpdateStmt stmt, ProofState state){
var state0 = state.Copy();
state0.InitTacFrame(stmt, true);
yield return state0;
}
public bool IsTacticCall(UpdateStmt us) {
Contract.Requires(us != null);
return IsTacticCall(Util.GetSignature(us));
}
public bool IsArgumentApplication(UpdateStmt us) {
Contract.Requires<ArgumentNullException>(us != null, "us");
var ns = Util.GetNameSegment(us);
return _scope.Peek().HasLocal(ns);
}
public static IEnumerable<object> EvaluateTacnyExpression(ProofState state, Expression expr) {
Contract.Requires<ArgumentNullException>(state != null, "state");
Contract.Requires<ArgumentNullException>(expr != null, "expr");
if (expr is NameSegment) {
var ns = (NameSegment)expr;
if (state.HasLocalValue(ns.Name)) {
yield return state.GetLocalValue(ns.Name);
} else {
yield return ns;
}
} else if (expr is ApplySuffix) {
var aps = (ApplySuffix)expr;
if (state.IsTacticCall(aps)) {
var us = new UpdateStmt(aps.tok, aps.tok, new List<Expression>() { aps.Lhs },
new List<AssignmentRhs>() { new ExprRhs(aps) });
foreach (var item in ApplyNestedTactic(state, state.DafnyVars(), us).Select(x => x.GetGeneratedCode())) {
yield return item;
}
}
// rewrite the expression
if (aps.Lhs is ExprDotName) {
foreach (var item in EvaluateTacnyExpression(state, aps.Lhs)) {
if (item is Expression) {
yield return new ApplySuffix(aps.tok, (Expression)item, aps.Args);
} else {
Contract.Assert(false, "Unexpected ExprNotName case");
}
}
} else {
// try to evaluate as tacny expression
string sig = Util.GetSignature(aps);
// using reflection find all classes that extend EAtomic
var types =
Assembly.GetAssembly(typeof(EAtomic.EAtomic)).GetTypes().Where(t => t.IsSubclassOf(typeof(EAtomic.EAtomic)));
foreach (var type in types) {
var resolverInstance = Activator.CreateInstance(type) as EAtomic.EAtomic;
if (sig == resolverInstance?.Signature) {
//TODO: validate input countx
foreach (var item in resolverInstance?.Generate(aps, state))
yield return item;
}
// if we reached this point, rewrite the apply suffix
foreach (var item in EvaluateTacnyExpression(state, aps.Lhs)) {
if (!(item is NameSegment)) {
//TODO: warning
} else {
var argList = new List<Expression>();
foreach (var arg in aps.Args) {
foreach (var result in EvaluateTacnyExpression(state, arg)) {
if (result is Expression)
argList.Add(result as Expression);
else
argList.Add(Util.VariableToExpression(result as IVariable));
break;
}
}
yield return new ApplySuffix(aps.tok, aps.Lhs, argList);
}
}
}
}
} else if (expr is ExprDotName) {
var edn = (ExprDotName)expr;
var ns = edn.Lhs as NameSegment;
if (ns != null && state.ContainsVariable(ns)) {
var newLhs = state.GetLocalValue(ns);
var lhs = newLhs as Expression;
if (lhs != null)
yield return new ExprDotName(edn.tok, lhs, edn.SuffixName, edn.OptTypeArguments);
}
yield return edn;
} else if (expr is UnaryOpExpr) {
var op = (UnaryOpExpr)expr;
foreach (var result in EvaluateTacnyExpression(state, op.E)) {
switch (op.Op) {
case UnaryOpExpr.Opcode.Cardinality:
if (!(result is IEnumerable)) {
var resultExp = result is IVariable
? Util.VariableToExpression(result as IVariable)
: result as Expression;
yield return new UnaryOpExpr(op.tok, op.Op, resultExp);
} else {
var enumerator = result as IList;
if (enumerator != null)
yield return new Dafny.LiteralExpr(op.tok, enumerator.Count);
}
yield break;
case UnaryOpExpr.Opcode.Not:
if (result is Dafny.LiteralExpr) {
var lit = (Dafny.LiteralExpr)result;
if (lit.Value is bool) {
// inverse the bool value
yield return new Dafny.LiteralExpr(op.tok, !(bool)lit.Value);
} else {
Contract.Assert(false);
//TODO: error message
}
} else {
var resultExp = result is IVariable ? Util.VariableToExpression(result as IVariable) : result as Expression;
yield return new UnaryOpExpr(op.tok, op.Op, resultExp);
}
yield break;
default:
Contract.Assert(false, "Unsupported Unary Operator");
yield break;
}
}
} else if (expr is DisplayExpression) {
var dexpr = (DisplayExpression)expr;
if (dexpr.Elements.Count == 0) {
yield return dexpr.Copy();
} else {
foreach (var item in ResolveDisplayExpression(state, dexpr)) {
yield return item;
}
}
} else { yield return expr; }
}
private static IEnumerable<ProofState> UpdateLocalValue(UpdateStmt us, ProofState state) {
Contract.Requires<ArgumentNullException>(us != null, "stmt");
Contract.Requires<ArgumentNullException>(state != null, "state");
Contract.Requires<ArgumentException>(state.IsLocalAssignment(us), "stmt");
foreach (var item in us.Rhss) {
int index = us.Rhss.IndexOf(item);
Contract.Assert(us.Lhss.ElementAtOrDefault(index) != null, "register var err");
var exprRhs = item as ExprRhs;
if (exprRhs?.Expr is ApplySuffix) {
var aps = (ApplySuffix)exprRhs.Expr;
foreach (var result in EvaluateTacnyExpression(state, aps)) {
state.UpdateLocal(((NameSegment)us.Lhss[index]).Name, result);
}
} else if (exprRhs?.Expr is Dafny.LiteralExpr) {
state.UpdateLocal(((NameSegment)us.Lhss[index]).Name, (Dafny.LiteralExpr)exprRhs?.Expr);
} else {
state.UpdateLocal(((NameSegment)us.Lhss[index]).Name, exprRhs?.Expr);
}
}
yield return state.Copy();
}
public static ProofState ApplyTactic(ProofState state, Dictionary<IVariable, Type> variables,
UpdateStmt tacticApplication) {
Contract.Requires<ArgumentNullException>(tcce.NonNull(variables));
Contract.Requires<ArgumentNullException>(tcce.NonNull(tacticApplication));
Contract.Requires<ArgumentNullException>(state != null, "state");
state.InitState(tacticApplication, variables);
var search = new BaseSearchStrategy(state.TacticInfo.SearchStrategy, true);
return search.Search(state, _errorReporterDelegate).FirstOrDefault();
}
public static IEnumerable<ProofState> ApplyNestedTactic(ProofState state, Dictionary<IVariable, Type> variables,
UpdateStmt tacticApplication) {
Contract.Requires<ArgumentNullException>(tcce.NonNull(variables));
Contract.Requires<ArgumentNullException>(tcce.NonNull(tacticApplication));
Contract.Requires<ArgumentNullException>(state != null, "state");
state.InitState(tacticApplication, variables);
var search = new BaseSearchStrategy(state.TacticInfo.SearchStrategy, false);
foreach (var result in search.Search(state, _errorReporterDelegate)) {
var c = state.Copy();
c.AddStatementRange(result.GetGeneratedCode());
yield return c;
}
}
public void FindAndResolveTacticApplication(Program tacnyProgram, Function fun) {
if (IsLeaf()) {
var aps = Data as ApplySuffix;
if (aps == null)
return;
UpdateStmt us = new UpdateStmt(aps.tok, aps.tok, new List<Expression>(), new List<AssignmentRhs> { new ExprRhs(aps) });
if (tacnyProgram.IsTacticCall(us)) {
List<IVariable> variables = new List<IVariable>();
ITactic tac = tacnyProgram.GetTactic(us);
tacnyProgram.SetCurrent(tac, fun);
variables.AddRange(fun.Formals);
// get the resolved variables
List<IVariable> resolved = new List<IVariable>();
Console.Out.WriteLine($"Resolving {tac.Name} in {fun.Name}");
resolved.AddRange(fun.Formals); // add input arguments as resolved variables
var result = LazyTacny.Atomic.ResolveTactic(us, fun, tacnyProgram, variables, resolved);
Data = result.State.DynamicContext.generatedExpressions[0];
tacnyProgram.CurrentDebug.Fin();
Modified = true;
}
} else {
LChild.FindAndResolveTacticApplication(tacnyProgram, fun);
RChild?.FindAndResolveTacticApplication(tacnyProgram, fun);
}
}
void VarDeclStatement(out Statement/*!*/ s) {
IToken x = null, assignTok = null; bool isGhost = false;
LocalVariable d;
AssignmentRhs r;
List<LocalVariable> lhss = new List<LocalVariable>();
List<AssignmentRhs> rhss = new List<AssignmentRhs>();
IToken suchThatAssume = null;
Expression suchThat = null;
Attributes attrs = null;
IToken endTok;
s = dummyStmt;
if (la.kind == 65) {
Get();
isGhost = true; x = t;
}
Expect(61);
if (!isGhost) { x = t; }
if (la.kind == 1 || la.kind == 46) {
while (la.kind == 46) {
Attribute(ref attrs);
}
LocalIdentTypeOptional(out d, isGhost);
lhss.Add(d); d.Attributes = attrs; attrs = null;
while (la.kind == 22) {
Get();
while (la.kind == 46) {
Attribute(ref attrs);
}
LocalIdentTypeOptional(out d, isGhost);
lhss.Add(d); d.Attributes = attrs; attrs = null;
}
if (la.kind == 25 || la.kind == 46 || la.kind == 104) {
if (la.kind == 104) {
Get();
assignTok = t;
Rhs(out r);
rhss.Add(r);
while (la.kind == 22) {
Get();
Rhs(out r);
rhss.Add(r);
}
} else {
while (la.kind == 46) {
Attribute(ref attrs);
}
Expect(25);
assignTok = t;
if (la.kind == _assume) {
Expect(31);
suchThatAssume = t;
}
Expression(out suchThat, false, true);
}
}
while (!(la.kind == 0 || la.kind == 28)) {SynErr(198); Get();}
Expect(28);
endTok = t;
ConcreteUpdateStatement update;
if (suchThat != null) {
var ies = new List<Expression>();
foreach (var lhs in lhss) {
ies.Add(new IdentifierExpr(lhs.Tok, lhs.Name));
}
update = new AssignSuchThatStmt(assignTok, endTok, ies, suchThat, suchThatAssume, attrs);
} else if (rhss.Count == 0) {
update = null;
} else {
var ies = new List<Expression>();
foreach (var lhs in lhss) {
ies.Add(new AutoGhostIdentifierExpr(lhs.Tok, lhs.Name));
}
update = new UpdateStmt(assignTok, endTok, ies, rhss);
}
s = new VarDeclStmt(x, endTok, lhss, update);
} else if (la.kind == 50) {
Get();
var letLHSs = new List<CasePattern>();
var letRHSs = new List<Expression>();
List<CasePattern> arguments = new List<CasePattern>();
CasePattern pat;
Expression e = dummyExpr;
IToken id = t;
if (la.kind == 1 || la.kind == 50) {
CasePattern(out pat);
arguments.Add(pat);
while (la.kind == 22) {
Get();
CasePattern(out pat);
arguments.Add(pat);
}
}
Expect(51);
theBuiltIns.TupleType(id, arguments.Count, true); // make sure the tuple type exists
string ctor = BuiltIns.TupleTypeCtorName; //use the TupleTypeCtors
pat = new CasePattern(id, ctor, arguments);
if (isGhost) { pat.Vars.Iter(bv => bv.IsGhost = true); }
letLHSs.Add(pat);
if (la.kind == 104) {
Get();
} else if (la.kind == 25 || la.kind == 46) {
while (la.kind == 46) {
Attribute(ref attrs);
}
Expect(25);
SemErr(pat.tok, "LHS of assign-such-that expression must be variables, not general patterns");
} else SynErr(199);
Expression(out e, false, true);
letRHSs.Add(e);
Expect(28);
s = new LetStmt(e.tok, e.tok, letLHSs, letRHSs);
} else SynErr(200);
}
private Solution ResolveTactic(List<IVariable> variables, List<IVariable> resolved, UpdateStmt us, MemberDecl md, WhileStmt ws = null) {
try
{
var prog = Util.ObjectExtensions.Copy(_tacnyProgram);
var result = Atomic.ResolveTactic(us, md, prog, variables, resolved, ws);
prog.PrintDebugData(prog.CurrentDebug);
return result;
} catch (Exception e) {
Printer.Error(e.Message);
return null;
}
}
public bool IsTacticCall(UpdateStmt us)
{
return(IsTacticCall(GetSignature(us)));
}
void IVisitor.VisitOnUpdate(UpdateStmt updateStmt)
{
this.ParentExists(updateStmt);
}
/// <summary>
/// Get called tactic
/// </summary>
/// <param name="us"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"> </exception>
/// /// <exception cref="ArgumentException"> Provided UpdateStmt is not a tactic application</exception>
public ITactic GetTactic(UpdateStmt us) {
Contract.Requires(us != null);
Contract.Requires<ArgumentException>(IsTacticCall(us));
Contract.Ensures(Contract.Result<ITactic>() != null);
return GetTactic(Util.GetSignature(us));
}
public Context(MemberDecl md, UpdateStmt tac_call) {
Contract.Requires(md != null && tac_call != null);
this.md = md;
this.tac_call = tac_call;
}
public bool IsLocalAssignment(UpdateStmt us) {
if (us.Lhss.Count == 0)
return false;
foreach (var lhs in us.Lhss) {
if (!(lhs is NameSegment))
return false;
if (!_scope.Peek().IsDeclared((lhs as NameSegment).Name))
return false;
}
return true;
}
void IVisitor.VisitOnWhere(UpdateStmt updateStmt, int offset)
{
this.ParentExists(updateStmt);
}
public virtual Statement CloneStmt(Statement stmt) {
if (stmt == null) {
return null;
}
Statement r;
if (stmt is AssertStmt) {
var s = (AssertStmt)stmt;
r = new AssertStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Expr), null);
} else if (stmt is AssumeStmt) {
var s = (AssumeStmt)stmt;
r = new AssumeStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Expr), null);
} else if (stmt is TacticInvariantStmt) {
var s = (TacticInvariantStmt)stmt;
r = new TacticInvariantStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Expr), null, s.IsObjectLevel);
} else if (stmt is TacticAssertStmt) {
var s = (TacticAssertStmt)stmt;
r = new TacticAssertStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Expr), null, s.IsObjectLevel);
} else if (stmt is PrintStmt) {
var s = (PrintStmt)stmt;
r = new PrintStmt(Tok(s.Tok), Tok(s.EndTok), s.Args.ConvertAll(CloneExpr));
} else if (stmt is BreakStmt) {
var s = (BreakStmt)stmt;
if (s.TargetLabel != null) {
r = new BreakStmt(Tok(s.Tok), Tok(s.EndTok), s.TargetLabel);
} else {
r = new BreakStmt(Tok(s.Tok), Tok(s.EndTok), s.BreakCount);
}
} else if (stmt is ReturnStmt) {
var s = (ReturnStmt)stmt;
r = new ReturnStmt(Tok(s.Tok), Tok(s.EndTok), s.rhss == null ? null : s.rhss.ConvertAll(CloneRHS));
} else if (stmt is YieldStmt) {
var s = (YieldStmt)stmt;
r = new YieldStmt(Tok(s.Tok), Tok(s.EndTok), s.rhss == null ? null : s.rhss.ConvertAll(CloneRHS));
} else if (stmt is AssignStmt) {
var s = (AssignStmt)stmt;
r = new AssignStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Lhs), CloneRHS(s.Rhs));
} else if (stmt is BlockStmt) {
r = CloneBlockStmt((BlockStmt)stmt);
} else if (stmt is IfStmt) {
var s = (IfStmt)stmt;
r = new IfStmt(Tok(s.Tok), Tok(s.EndTok), s.IsExistentialGuard, CloneExpr(s.Guard), CloneBlockStmt(s.Thn), CloneStmt(s.Els));
} else if (stmt is AlternativeStmt) {
var s = (AlternativeStmt)stmt;
r = new AlternativeStmt(Tok(s.Tok), Tok(s.EndTok), s.Alternatives.ConvertAll(CloneGuardedAlternative));
} else if (stmt is WhileStmt) {
var s = (WhileStmt)stmt;
r = new WhileStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Guard), s.Invariants.ConvertAll(CloneMayBeFreeExpr), CloneSpecExpr(s.Decreases), CloneSpecFrameExpr(s.Mod), CloneBlockStmt(s.Body));
((WhileStmt)r).TacAps = s.TacAps;
} else if (stmt is AlternativeLoopStmt) {
var s = (AlternativeLoopStmt)stmt;
r = new AlternativeLoopStmt(Tok(s.Tok), Tok(s.EndTok), s.Invariants.ConvertAll(CloneMayBeFreeExpr), CloneSpecExpr(s.Decreases), CloneSpecFrameExpr(s.Mod), s.Alternatives.ConvertAll(CloneGuardedAlternative));
} else if (stmt is ForallStmt) {
var s = (ForallStmt)stmt;
r = new ForallStmt(Tok(s.Tok), Tok(s.EndTok), s.BoundVars.ConvertAll(CloneBoundVar), null, CloneExpr(s.Range), s.Ens.ConvertAll(CloneMayBeFreeExpr), CloneStmt(s.Body));
if (s.ForallExpressions != null) {
((ForallStmt)r).ForallExpressions = s.ForallExpressions.ConvertAll(CloneExpr);
}
} else if (stmt is CalcStmt) {
var s = (CalcStmt)stmt;
// calc statements have the unusual property that the last line is duplicated. If that is the case (which
// we expect it to be here), we share the clone of that line as well.
var lineCount = s.Lines.Count;
var lines = new List<Expression>(lineCount);
for (int i = 0; i < lineCount; i++) {
lines.Add(i == lineCount - 1 && 2 <= lineCount && s.Lines[i] == s.Lines[i - 1] ? lines[i - 1] : CloneExpr(s.Lines[i]));
}
Contract.Assert(lines.Count == lineCount);
r = new CalcStmt(Tok(s.Tok), Tok(s.EndTok), CloneCalcOp(s.Op), lines, s.Hints.ConvertAll(CloneBlockStmt), s.StepOps.ConvertAll(CloneCalcOp), CloneCalcOp(s.ResultOp), CloneAttributes(s.Attributes));
} else if (stmt is MatchStmt) {
var s = (MatchStmt)stmt;
r = new MatchStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Source),
s.Cases.ConvertAll(CloneMatchCaseStmt), s.UsesOptionalBraces);
} else if (stmt is AssignSuchThatStmt) {
var s = (AssignSuchThatStmt)stmt;
r = new AssignSuchThatStmt(Tok(s.Tok), Tok(s.EndTok), s.Lhss.ConvertAll(CloneExpr), CloneExpr(s.Expr), s.AssumeToken == null ? null : Tok(s.AssumeToken), null);
} else if (stmt is UpdateStmt) {
var s = (UpdateStmt)stmt;
r = new UpdateStmt(Tok(s.Tok), Tok(s.EndTok), s.Lhss.ConvertAll(CloneExpr), s.Rhss.ConvertAll(CloneRHS), s.CanMutateKnownState);
} else if (stmt is VarDeclStmt) {
var s = (VarDeclStmt)stmt;
var lhss = s.Locals.ConvertAll(c => new LocalVariable(Tok(c.Tok), Tok(c.EndTok), c.Name, CloneType(c.OptionalType), c.IsGhost));
r = new VarDeclStmt(Tok(s.Tok), Tok(s.EndTok), lhss, (ConcreteUpdateStatement)CloneStmt(s.Update));
} else if (stmt is LetStmt) {
var s = (LetStmt)stmt;
r = new LetStmt(Tok(s.Tok), Tok(s.EndTok), s.LHSs.ConvertAll(CloneCasePattern), s.RHSs.ConvertAll(CloneExpr));
} else if (stmt is ModifyStmt) {
var s = (ModifyStmt)stmt;
var mod = CloneSpecFrameExpr(s.Mod);
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
r = new ModifyStmt(Tok(s.Tok), Tok(s.EndTok), mod.Expressions, mod.Attributes, body);
} else if (stmt is TacnyCasesBlockStmt) {
var s = (TacnyCasesBlockStmt)stmt;
var guard = CloneExpr(s.Guard);
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
r = new TacnyCasesBlockStmt(Tok(s.Tok), Tok(s.EndTok), guard, body);
} else if (stmt is TacnyChangedBlockStmt) {
var s = (TacnyChangedBlockStmt)stmt;
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
r = new TacnyChangedBlockStmt(Tok(s.Tok), Tok(s.EndTok), body);
} else if (stmt is TacnySolvedBlockStmt) {
var s = (TacnySolvedBlockStmt)stmt;
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
r = new TacnySolvedBlockStmt(Tok(s.Tok), Tok(s.EndTok), body);
} else if (stmt is TacnyTryCatchBlockStmt) {
var s = (TacnyTryCatchBlockStmt)stmt;
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
var c = s.Ctch == null ? null : CloneBlockStmt(s.Ctch);
r = new TacnyTryCatchBlockStmt(Tok(s.Tok), Tok(s.EndTok), body, c);
} else if (stmt is TacticVarDeclStmt) {
var s = (TacticVarDeclStmt)stmt;
var lhss = s.Locals.ConvertAll(c => new LocalVariable(Tok(c.Tok), Tok(c.EndTok), c.Name, CloneType(c.OptionalType), c.IsGhost));
r = new TacticVarDeclStmt(Tok(s.Tok), Tok(s.EndTok), lhss, (ConcreteUpdateStatement)CloneStmt(s.Update));
} else {
Contract.Assert(false); throw new cce.UnreachableException(); // unexpected statement
}
// add labels to the cloned statement
AddStmtLabels(r, stmt.Labels);
r.Attributes = CloneAttributes(stmt.Attributes);
return r;
}
private void FindRemovableTypesInUpdateStmt(UpdateStmt updateStmt, List<Statement> parent, Method method, ClassDecl classDecl)
{
foreach (var expr in updateStmt.Rhss) {
if (!IsAssignmentLemmaCall(expr, classDecl)) continue;
_allRemovableTypes.AddLemmaCall(new Wrap<Statement>(updateStmt, parent), method);
}
}
public StaticContext(MemberDecl md, UpdateStmt tac_call, Program program)
: base(md, tac_call) {
this.program = program;
foreach (DatatypeDecl tld in program.Globals)
datatypes.Add(tld.Name, tld);
}
public override IEnumerable<ProofState> Generate(Statement statement, ProofState state) {
List<List<IVariable>> args = new List<List<IVariable>>();
List<IVariable> mdIns = new List<IVariable>();
List<Expression> callArguments;
IVariable lv;
InitArgs(state, statement, out lv, out callArguments);
state.IfVerify = true;
//TODO: implement this properly
//var members = state.GetLocalValue(callArguments[0] as NameSegment) as IEnumerable<MemberDecl>;
//evaluate the argument (methods/lemma)
var members0 = Interpreter.EvalTacnyExpression(state, callArguments[0]).GetEnumerator();
members0.MoveNext();
var members = members0.Current as List<MemberDecl>;
if (members == null){
yield break;
}
foreach(var member in members) {
MemberDecl md;
mdIns.Clear();
args.Clear();
if(member is NameSegment) {
//TODO:
Console.WriteLine("double check this");
md = null;
// md = state.GetDafnyProgram(). Members.FirstOrDefault(i => i.Key == (member as NameSegment)?.Name).Value;
} else {
md = member as MemberDecl;
}
// take the membed decl parameters
var method = md as Method;
if(method != null)
mdIns.AddRange(method.Ins);
else if(md is Microsoft.Dafny.Function)
mdIns.AddRange(((Microsoft.Dafny.Function)md).Formals);
else
Contract.Assert(false, "In Explore Atomic call," + callArguments[0] + "is neither a Method or a Function");
//evaluate the arguemnts for the lemma to be called
var instArgs = Interpreter.EvalTacnyExpression(state, callArguments[1]);
foreach(var ovars in instArgs) {
Contract.Assert(ovars != null, "In Explore Atomic call," + callArguments[1] + "is not variable");
List<IVariable> vars = ovars as List<IVariable> ?? new List<IVariable>();
//Contract.Assert(vars != null, Util.Error.MkErr(call_arguments[0], 1, typeof(List<IVariable>)));
//for the case when no args, just add an empty list
if (mdIns.Count == 0){
args.Add(new List<IVariable>());
}
for(int i = 0; i < mdIns.Count; i++) {
var item = mdIns[i];
args.Add(new List<IVariable>());
foreach(var arg in vars) {
// get variable type
Type type = state.GetDafnyVarType(arg.Name);
if(type != null) {
if(type is UserDefinedType && item.Type is UserDefinedType) {
var udt1 = type as UserDefinedType;
var udt2 = item.Type as UserDefinedType;
if(udt1.Name == udt2.Name)
args[i].Add(arg);
} else {
// if variable type and current argument types match, or the type is yet to be inferred
if(item.Type.ToString() == type.ToString() || type is InferredTypeProxy)
args[i].Add(arg);
}
} else
args[i].Add(arg);
}
/**
* if no type correct variables have been added we can safely return
* because we won't be able to generate valid calls
*/
if(args[i].Count == 0) {
Debug.WriteLine("No type matching variables were found");
yield break;
}
}
foreach(var result in PermuteArguments(args, 0, new List<NameSegment>())) {
// create new fresh list of items to remove multiple references to the same object
List<Expression> newList = result.Cast<Expression>().ToList().Copy();
//TODO: need to double check wirh Vito, why can't use copy ?
//Util.Copy.CopyExpressionList(result.Cast<Expression>().ToList());
ApplySuffix aps = new ApplySuffix(callArguments[0].tok, new NameSegment(callArguments[0].tok, md.Name, null),
newList);
if(lv != null) {
var newState = state.Copy();
newState.AddTacnyVar(lv, aps);
yield return newState;
} else {
var newState = state.Copy();
UpdateStmt us = new UpdateStmt(aps.tok, aps.tok, new List<Expression>(),
new List<AssignmentRhs> { new ExprRhs(aps) });
//Printer p = new Printer(Console.Out);
//p.PrintStatement(us,0);
newState.AddStatement(us);
yield return newState;
}
}
}
}
}
void IVisitor.VisitAfter(UpdateStmt updateStmt)
{
this.ParentExists(updateStmt);
}
public static bool IsPartial(ProofState state, UpdateStmt tacticApplication) {
//still need to check the localtion of the application, is it the last call ? is it a neswted call ?
if(state.FrameCtrlInfo.IsPartial) {
return true;
}
return tacticApplication.Rhss[0].Attributes != null && ParsePartialAttribute(tacticApplication.Rhss[0].Attributes);
}
