/// <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); }