/// <summary> /// /// </summary> /// <param name="line"></param> /// <param name="ns"></param> /// <param name="datatype"></param> /// <param name="fL"></param>a function list which contains a function to generate stetment list with given line number /// <returns></returns> private MatchStmt GenerateMatchStmt(int line, NameSegment ns, DatatypeDecl datatype, List <Func <int, List <Statement> > > fL) { Contract.Requires(ns != null); Contract.Requires(datatype != null); Contract.Ensures(Contract.Result <MatchStmt>() != null); List <MatchCaseStmt> cases = new List <MatchCaseStmt>(); int index = TacnyDriver.TacticCodeTokLine;//line + 1; for (int j = 0; j < datatype.Ctors.Count; j++) { var dc = datatype.Ctors[j]; Func <int, List <Statement> > f = _ => new List <Statement>(); if (j < fL.Count) { f = fL[j]; } MatchCaseStmt mcs = GenerateMatchCaseStmt(index, dc, f); cases.Add(mcs); line += mcs.Body.Count + 1; } return(new MatchStmt(new Token(index, 0) { val = "match" }, new Token(index, 0) { val = "=>" }, ns, cases, false)); }
private static IEnumerable <List <NameSegment> > PermuteArguments(List <List <IVariable> > args, int depth, List <NameSegment> current) { if (args.Count == 0) { yield break; } if (depth == args.Count) { yield return(current); yield break; } if (args[depth].Count == 0) { yield return(new List <NameSegment>()); yield break; } for (int i = 0; i < args[depth].Count; ++i) { List <NameSegment> tmp = new List <NameSegment>(); tmp.AddRange(current); IVariable iv = args[depth][i]; NameSegment ns = new NameSegment(iv.Tok, iv.Name, null); tmp.Add(ns); foreach (var item in PermuteArguments(args, depth + 1, tmp)) { yield return(item); } } }
public bool HasLocalWithName(NameSegment ns) { Contract.Requires <ArgumentNullException>(ns != null); List <IVariable> ins = new List <IVariable>(localDeclarations.Keys); var key = ins.FirstOrDefault(i => i.Name == ns.Name); return(key != null); }
/// <summary> /// Resolve all variables in expression to either literal values /// or to orignal declared nameSegments /// </summary> /// <param name="guard"></param> /// <param name="state"></param> /// <returns></returns> public static IEnumerable <ExpressionTree> ResolveExpression(ExpressionTree guard, ProofState state) { Contract.Requires <ArgumentNullException>(guard != null, "guard"); Contract.Requires <ArgumentNullException>(state != null, "state"); if (guard.IsLeaf()) { if (!(guard.Data is NameSegment)) { yield return(guard.Copy()); } var newGuard = guard.Copy(); var result = EvaluateLeaf(newGuard, state); foreach (var item in result) { Contract.Assert(result != null); Expression newNs = null; // potential encapsulation problems if (item is MemberDecl) { var md = item as MemberDecl; newNs = new StringLiteralExpr(new Token(), md.Name, true); } else if (item is Formal) { var tmp = item as Formal; newNs = new NameSegment(tmp.tok, tmp.Name, null); } else if (item is NameSegment) { newNs = item as NameSegment; } else { newNs = item as Expression; // Dafny.LiteralExpr; } newGuard.Data = newNs; yield return(newGuard); } } else { foreach (var lChild in ResolveExpression(guard.LChild, state)) { if (guard.RChild != null) { foreach (var rChild in ResolveExpression(guard.RChild, state)) { yield return(new ExpressionTree(guard.Data, null, lChild, rChild)); } } else { yield return(new ExpressionTree(guard.Data, null, lChild, null)); } } } }
private void IsDatatype(Statement st, ref List <Solution> solution_list) { List <Expression> call_arguments = null; IVariable lv = null; IVariable declaration = null; Dafny.LiteralExpr lit = null; Dafny.Type type = null; InitArgs(st, out lv, out call_arguments); Contract.Assert(tcce.OfSize(call_arguments, 1), Util.Error.MkErr(st, 0, 1, call_arguments.Count)); NameSegment argument = call_arguments[0] as NameSegment; Contract.Assert(argument != null, Util.Error.MkErr(st, 1, typeof(NameSegment))); declaration = GetLocalValueByName(argument) as IVariable; Contract.Assert(declaration != null, Util.Error.MkErr(st, 1, typeof(IVariable))); if (declaration.Type == null) { type = globalContext.GetVariableType(declaration.Name); } else { type = declaration.Type; } // type of the argument is unknown thus it's not a datatype if (type != null && type.IsDatatype) { lit = new Dafny.LiteralExpr(st.Tok, true); } else { // check if the argument is a nested data type Dafny.UserDefinedType udt = type as Dafny.UserDefinedType; if (udt != null) { if (globalContext.datatypes.ContainsKey(udt.Name)) { lit = new Dafny.LiteralExpr(st.Tok, true); } else { lit = new Dafny.LiteralExpr(st.Tok, false); } } else { lit = new Dafny.LiteralExpr(st.Tok, false); } } Contract.Assert(lit != null); localContext.AddLocal(lv, lit); }
private void ReplaceTerm(Expression old_singleton, Expression new_term, ExpressionTree formula, ref List <Expression> nexp) { Contract.Requires(nexp != null); Contract.Requires(old_singleton != null); Contract.Requires(new_term != null); NameSegment curNs = null; NameSegment oldNs = null; if (formula == null) { return; } if (formula.isLeaf()) { if (formula.data.GetType() == old_singleton.GetType() && formula.was_replaced == false) { if (formula.data is NameSegment) { curNs = (NameSegment)formula.data; oldNs = (NameSegment)old_singleton; } else if (formula.data is UnaryOpExpr) { curNs = (NameSegment)((UnaryOpExpr)formula.data).E; oldNs = (NameSegment)((UnaryOpExpr)old_singleton).E; } else { Contract.Assert(false, Util.Error.MkErr(formula.data, -1)); } if (curNs.Name == oldNs.Name) { ExpressionTree nt = formula.Copy(); nt.data = new_term; if (nt.parent.lChild == nt) { nt.parent.lChild = nt; } else { nt.parent.rChild = nt; } nexp.Add(nt.root.TreeToExpression()); } } return; } ReplaceTerm(old_singleton, new_term, formula.lChild, ref nexp); ReplaceTerm(old_singleton, new_term, formula.rChild, ref nexp); }
private IEnumerable <object> ResolveExpression(Expression expr, IVariable declaration) { Contract.Requires(expr != null); if (expr is BinaryExpr) { BinaryExpr bexp = expr as BinaryExpr; switch (bexp.Op) { case BinaryExpr.Opcode.In: NameSegment var = bexp.E0 as NameSegment; Contract.Assert(var != null, Error.MkErr(bexp, 6, declaration.Name)); Contract.Assert(var.Name == declaration.Name, Error.MkErr(bexp, 6, var.Name)); foreach (var result in ResolveExpression(bexp.E1)) { if (result is IEnumerable) { dynamic resultList = result; foreach (var item in resultList) { yield return(item); } } } yield break; case BinaryExpr.Opcode.And: // for each item in the resolved lhs of the expression foreach (var item in ResolveExpression(bexp.E0, declaration)) { Atomic copy = Copy(); copy.AddLocal(declaration, item); // resolve the rhs expression foreach (var res in copy.ResolveExpression(bexp.E1)) { LiteralExpr lit = res as LiteralExpr; // sanity check Contract.Assert(lit != null, Error.MkErr(expr, 17)); if (lit.Value is bool) { // if resolved to true if ((bool)lit.Value) { yield return(item); } } } } yield break; } } }
public string GenerateConditionString(NameSegment expression, IDictionary <string, string> rename) { var isFormal = !expression.Type.IsArrowType; if (isFormal) { if (rename.ContainsKey(expression.tok.val)) { return(rename[expression.tok.val]); } else { return(expression.tok.val); } } else { return(expression.tok.val); } }
private MatchStmt GenerateMatchStmt(int index, NameSegment ns, DatatypeDecl datatype, List <Solution> body) { Contract.Requires(ns != null); Contract.Requires(datatype != null); Contract.Ensures(Contract.Result <MatchStmt>() != null); List <MatchCaseStmt> cases = new List <MatchCaseStmt>(); int line = index + 1; int i = 0; foreach (DatatypeCtor dc in datatype.Ctors) { MatchCaseStmt mcs; GenerateMatchCaseStmt(line, dc, body[i], out mcs); cases.Add(mcs); line += mcs.Body.Count + 1; i++; } return(new MatchStmt(CreateToken("match", index, 0), CreateToken("=>", index, 0), ns, cases, false)); }
public override void Visit(NameSegment e) { var nav = new SymbolNavigator(); var resolvedSymbol = nav.TopDown(RootNode, e.ResolvedExpression.tok); var declaration = FindDeclaration(e.Name, resolvedSymbol); CreateSymbol( name: e.Name, kind: null, type: e.Type, positionAsToken: e.tok, bodyStartPosAsToken: null, bodyEndPosAsToken: null, isDeclaration: false, declarationSymbol: declaration, addUsageAtDeclaration: true, canHaveChildren: false, canBeUsed: false ); }
/// <summary> /// TODO: Resolve the bodies lazily /// </summary> /// <param name="datatype"></param> /// <param name="casesGuard"></param> /// <param name="st"></param> /// <returns></returns> private IEnumerable <Solution> GenerateStmt(DatatypeDecl datatype, NameSegment casesGuard, TacnyCasesBlockStmt st) { List <List <Solution> > allCtorBodies = Repeated(new List <Solution>(), datatype.Ctors.Count); int ctor = 0; foreach (var list in allCtorBodies) { list.Add(null); RegisterLocals(datatype, ctor); foreach (var result in ResolveBody(st.Body)) { list.Add(result); } RemoveLocals(datatype, ctor); ctor++; } foreach (var stmt in GenerateAllMatchStmt(DynamicContext.tac_call.Tok.line, 0, Util.Copy.CopyNameSegment(casesGuard), datatype, allCtorBodies, new List <Solution>())) { yield return(CreateSolution(this, stmt)); } }
public bool HasLocalWithName(NameSegment ns) { Contract.Requires<ArgumentNullException>(ns != null); List<IVariable> ins = new List<IVariable>(localDeclarations.Keys); var key = ins.FirstOrDefault(i => i.Name == ns.Name); return key != null; }
/// <summary> /// Get the value of local variable /// </summary> /// <param name="key"></param> /// <returns></returns> public object GetLocalValue(NameSegment key) { Contract.Requires<ArgumentNullException>(key != null, "key"); Contract.Ensures(Contract.Result<object>() != null); return GetLocalValue(key.Name); }
public object GetLocalValueByName(NameSegment ns) { Contract.Requires<ArgumentNullException>(ns != null); return GetLocalValueByName(ns.Name); }
public virtual void Visit(NameSegment nameSegment) { }
/// <summary> /// Return Dafny key /// </summary> /// <param name="key">Variable name</param> /// <returns>bool</returns> /// <exception cref="KeyNotFoundException">Variable does not exist in the current context</exception> public IVariable GetVariable(NameSegment key) { Contract.Requires<ArgumentNullException>(tcce.NonNull(key)); Contract.Ensures(Contract.Result<IVariable>() != null); return GetVariable(key.Name); }
private static IEnumerable<List<NameSegment>> PermuteArguments(List<List<IVariable>> args, int depth, List<NameSegment> current) { if(args.Count == 0) yield break; if(depth == args.Count) { yield return current; yield break; } if (args[depth].Count == 0){ yield return new List<NameSegment>(); yield break; } for(int i = 0; i < args[depth].Count; ++i) { List<NameSegment> tmp = new List<NameSegment>(); tmp.AddRange(current); IVariable iv = args[depth][i]; NameSegment ns = new NameSegment(iv.Tok, iv.Name, null); tmp.Add(ns); foreach(var item in PermuteArguments(args, depth + 1, tmp)) yield return item; } }
public string GenerateString(NameSegment expression) { return(expression.tok.val); }
/// <summary> /// /// </summary> /// <param name="line"></param> /// <param name="ns"></param> /// <param name="datatype"></param> /// <param name="f"></param>a function list which contains a function to generate stetment list with given line number /// <returns></returns> private MatchStmt GenerateMatchStmt (int line, NameSegment ns, DatatypeDecl datatype, List<Func<int, List<Statement>>> fL) { Contract.Requires(ns != null); Contract.Requires(datatype != null); Contract.Ensures(Contract.Result<MatchStmt>() != null); List<MatchCaseStmt> cases = new List<MatchCaseStmt>(); int index = Interpreter.TACNY_CODE_TOK_LINE;//line + 1; int i = 0; for (int j = 0; j < datatype.Ctors.Count; j++){ var dc = datatype.Ctors[j]; Func<int, List<Statement>> f = _=> new List<Statement>(); if (j < fL.Count) f = fL[j]; MatchCaseStmt mcs = GenerateMatchCaseStmt(index, dc, f); cases.Add(mcs); line += mcs.Body.Count + 1; i++; } return new MatchStmt(new Token(index, 0) { val = "match" }, new Token(index, 0) { val = "=>"}, ns, cases, false); }
public override void Visit(NameSegment nameSegment) { _cancellationToken.ThrowIfCancellationRequested(); RegisterDesignator(_currentScope, nameSegment, nameSegment.tok, nameSegment.Name); }
/// <summary> /// Check if Dafny key exists in the current context /// </summary> /// <param name="key">Variable</param> /// <returns>bool</returns> public bool ContainsVariable(NameSegment key) { Contract.Requires <ArgumentNullException>(tcce.NonNull(key)); return(ContainsVariable(key.Name)); }
internal bool HasLocal(NameSegment key) { Contract.Requires <ArgumentNullException>(key != null, "key"); return(HasLocal(key.Name)); }
private void AddVariant(Statement st, ref List<Solution> solution_list) { List<Expression> call_arguments = null; List<Expression> dec_list = null; Expression input = null; InitArgs(st, out call_arguments); Contract.Assert(tcce.OfSize(call_arguments, 1), Util.Error.MkErr(st, 0, 1, call_arguments.Count)); StringLiteralExpr wildCard = call_arguments[0] as StringLiteralExpr; if (wildCard != null) { if (wildCard.Value.Equals("*")) input = new WildcardExpr(wildCard.tok); } else { // hack /* * TODO: * Implement propper variable replacement */ object tmp; ProcessArg(call_arguments[0], out tmp); Contract.Assert(tmp != null); IVariable form = tmp as IVariable; if (form != null) input = new NameSegment(form.Tok, form.Name, null); else if (tmp is BinaryExpr) { input = tmp as BinaryExpr; } else if (tmp is NameSegment) { input = tmp as NameSegment; } } WhileStmt ws = FindWhileStmt(globalContext.tac_call, globalContext.md); if (ws != null) { WhileStmt nws = null; dec_list = new List<Expression>(ws.Decreases.Expressions.ToArray()); dec_list.Add(input); Specification<Expression> decreases = new Specification<Expression>(dec_list, ws.Attributes); nws = new WhileStmt(ws.Tok, ws.EndTok, ws.Guard, ws.Invariants, decreases, ws.Mod, ws.Body); AddUpdated(ws, nws); } else { Method target = Program.FindMember(globalContext.program.ParseProgram(), localContext.md.Name) as Method; if (GetNewTarget() != null && GetNewTarget().Name == target.Name) target = GetNewTarget(); Contract.Assert(target != null, Util.Error.MkErr(st, 3)); dec_list = target.Decreases.Expressions; // insert new variants at the end of the existing variants list Contract.Assert(input != null); dec_list.Add(input); Specification<Expression> decreases = new Specification<Expression>(dec_list, target.Decreases.Attributes); Method result = null; dynamic lemma = null; if ((lemma = target as Lemma) != null) { result = new Lemma(lemma.tok, lemma.Name, lemma.HasStaticKeyword, lemma.TypeArgs, lemma.Ins, lemma.Outs, lemma.Req, lemma.Mod, lemma.Ens, decreases, lemma.Body, lemma.Attributes, lemma.SignatureEllipsis); } else if ((lemma = target as CoLemma) != null) { result = new CoLemma(lemma.tok, lemma.Name, lemma.HasStaticKeyword, lemma.TypeArgs, lemma.Ins, lemma.Outs, lemma.Req, lemma.Mod, lemma.Ens, decreases, lemma.Body, lemma.Attributes, lemma.SignatureEllipsis); } else result = new Method(target.tok, target.Name, target.HasStaticKeyword, target.IsGhost, target.TypeArgs, target.Ins, target.Outs, target.Req, target.Mod, target.Ens, decreases, target.Body, target.Attributes, target.SignatureEllipsis); // register new method this.localContext.new_target = result; globalContext.program.IncTotalBranchCount(globalContext.program.currentDebug); } solution_list.Add(new Solution(this.Copy())); }
public bool ContainTacnyVal(NameSegment key) { Contract.Requires<ArgumentNullException>(key != null, "key"); return ContainTacnyVal(key.Name); }
public override IEnumerable <ProofState> EvalInit(Statement statement, ProofState state) { Contract.Assume(statement != null); Contract.Assume(statement is TacticForallStmt); _stmt = statement as TacticForallStmt; Contract.Assert(_stmt != null); // do basic simplification // maybe do a check and throw an error instead? // fixme: error returns null! //var e = (ForallExpr) SimpTacticExpr.SimpTacExpr(state0, _stmt.Spec); var e = (ForallExpr)SimpExpr.SimpTacticExpr(state, _stmt.Spec); // var e = _stmt.Spec as ForallExpr; // to rename expressions RenameVar rn = new RenameVar(); // to rename in the body of statement RenameVar rnBody = new RenameVar(); List <String> usedVars = state.GetAllDafnyVars().Keys.ToList(); usedVars.AddRange(state.GetAllTVars().Keys.ToList()); //List<String> tmp = new List<string>(); AllVars.DeclaredVars(_stmt.Body.Body[0], ref usedVars); if (_stmt.Attributes != null && _stmt.Attributes.Name.Equals("vars")) { var attrs = _stmt.Attributes.Args; for (int i = 0; i < attrs.Count; i++) { // todo: should really report an errors if first condition does not hold var segment = attrs[i] as NameSegment; if (segment != null && i < e.BoundVars.Count) { NameSegment ns = segment; String fv; if (GenFreeVar(ns.Name, usedVars, out fv)) { rnBody.AddRename(ns.Name, fv); } rn.AddRename(e.BoundVars[i].Name, fv); } // else we should have an error _vars = new List <BoundVar>(); foreach (BoundVar bv in e.BoundVars) { _vars.Add(rn.CloneBoundVar(bv)); } } } else { _vars = e.BoundVars; } foreach (var tmp in _vars) { state.AddDafnyVar(tmp.Name, new ProofState.VariableData { Variable = tmp, Type = tmp.Type }); } // we could even break _ens into a set of all conjunctions? // what about forall x (forall y) x var expr = e.Term as BinaryExpr; if (expr != null && (expr.Op.Equals(BinaryExpr.Opcode.Imp))) { var be = expr; _range = rn.CloneExpr(be.E0); var t = new MaybeFreeExpression(rn.CloneExpr(be.E1)); var l = new List <MaybeFreeExpression> { t }; _ens = l; } else { _range = new LiteralExpr(_stmt.Tok, true); var t = new MaybeFreeExpression(rn.CloneExpr(e.Term)); var l = new List <MaybeFreeExpression> { t }; _ens = l; } // Note that we do not need to rename variables in the body (unless the variables in vars is changed) InitBasicFrameCtrl(new List <Statement>(), state.IsCurFramePartial(), null, VerifyN); state.AddNewFrame(this); var bodyFrame = new DefaultTacticFrameCtrl(); var newBody = rnBody.CloneBlockStmt(_stmt.Body); bodyFrame.InitBasicFrameCtrl(newBody.Body, state.IsCurFramePartial(), null, VerifyN); bodyFrame.IsPartial = IsPartial; state.AddNewFrame(bodyFrame); yield return(state); }
/// <summary> /// Return Dafny key /// </summary> /// <param name="key">Variable name</param> /// <returns>bool</returns> /// <exception cref="KeyNotFoundException">Variable does not exist in the current context</exception> public IVariable GetDafnyVar(NameSegment key) { Contract.Requires <ArgumentNullException>(Tcce.NonNull(key)); Contract.Ensures(Contract.Result <IVariable>() != null); return(GetDafnyVar(key.Name)); }
void NameSegmentForTypeName(out Expression e, bool inExpressionContext) { IToken id; List<Type> typeArgs; Ident(out id); OptGenericInstantiation(out typeArgs, inExpressionContext); e = new NameSegment(id, id.val, typeArgs); }
public bool ContainTVal(NameSegment key) { Contract.Requires <ArgumentNullException>(key != null, "key"); return(ContainTVal(key.Name)); }
/// <summary> /// Resolve all variables in expression to either literal values /// or to orignal declared nameSegments /// </summary> /// <param name="guard"></param> /// <param name="state"></param> /// <returns></returns> public static IEnumerable<ExpressionTree> ResolveExpression(ExpressionTree guard, ProofState state) { Contract.Requires<ArgumentNullException>(guard != null, "guard"); Contract.Requires<ArgumentNullException>(state != null, "state"); if (guard.IsLeaf()) { if (!(guard.Data is NameSegment)) { yield return guard.Copy(); } var newGuard = guard.Copy(); var result = EvaluateLeaf(newGuard, state); foreach (var item in result) { Contract.Assert(result != null); Expression newNs = null; // potential encapsulation problems if (item is MemberDecl) { var md = item as MemberDecl; newNs = new StringLiteralExpr(new Token(), md.Name, true); } else if (item is Formal) { var tmp = item as Formal; newNs = new NameSegment(tmp.tok, tmp.Name, null); } else if (item is NameSegment) { newNs = item as NameSegment; } else { newNs = item as Expression; // Dafny.LiteralExpr; } newGuard.Data = newNs; yield return newGuard; } } else { foreach (var lChild in ResolveExpression(guard.LChild, state)) { if (guard.RChild != null) { foreach (var rChild in ResolveExpression(guard.RChild, state)) { yield return new ExpressionTree(guard.Data, null, lChild, rChild); } } else { yield return new ExpressionTree(guard.Data, null, lChild, null); } } } }
/// <summary> /// Deep copy nameSegment /// </summary> /// <param name="old"></param> /// <returns></returns> public static NameSegment CopyNameSegment(NameSegment old) { return new NameSegment(old.tok, old.Name, old.OptTypeArguments); }
public object GetLocalValueByName(NameSegment ns) { Contract.Requires <ArgumentNullException>(ns != null); return(GetLocalValueByName(ns.Name)); }
private IEnumerable <MatchStmt> GenerateAllMatchStmt(int line_index, int depth, NameSegment ns, DatatypeDecl datatype, List <List <Solution> > bodies, List <Solution> curBody) { if (bodies.Count == 0) { yield break; } if (depth == bodies.Count) { MatchStmt ms = GenerateMatchStmt(line_index, Util.Copy.CopyNameSegment(ns), datatype, curBody); yield return(ms); yield break; } for (int i = 0; i < bodies[depth].Count; ++i) { List <Solution> tmp = new List <Solution>(); tmp.AddRange(curBody); tmp.Add(bodies[depth][i]); foreach (var item in GenerateAllMatchStmt(line_index, depth + 1, ns, datatype, bodies, tmp)) { yield return(item); } } }
private IEnumerable <Solution> GenerateMatch(TacnyCasesBlockStmt st) { NameSegment casesGuard; UserDefinedType datatypeType = null; var isElement = false; var guard = st.Guard as ParensExpression; if (guard == null) { casesGuard = st.Guard as NameSegment; } else { casesGuard = guard.E as NameSegment; } Contract.Assert(casesGuard != null, Error.MkErr(st, 2)); IVariable tacInput = GetLocalKeyByName(casesGuard); Contract.Assert(tacInput != null, Error.MkErr(st, 9, casesGuard.Name)); if (!(tacInput is Formal)) { tacInput = GetLocalValueByName(casesGuard) as IVariable; Contract.Assert(tacInput != null, Error.MkErr(st, 9, casesGuard.Name)); // the original if (tacInput != null) { casesGuard = new NameSegment(tacInput.Tok, tacInput.Name, null); } } else { // get the original declaration inside the method casesGuard = GetLocalValueByName(tacInput) as NameSegment; } string datatypeName = tacInput?.Type.ToString(); /** * TODO cleanup * if datatype is Element lookup the formal in global variable registry */ if (datatypeName == "Element") { isElement = true; var val = GetLocalValueByName(tacInput.Name); var decl = val as NameSegment; Contract.Assert(decl != null, Error.MkErr(st, 9, tacInput.Name)); var originalDecl = StaticContext.GetGlobalVariable(decl?.Name); if (originalDecl != null) { datatypeType = originalDecl.Type as UserDefinedType; datatypeName = datatypeType != null ? datatypeType.Name : originalDecl.Type.ToString(); } else { Contract.Assert(false, Error.MkErr(st, 9, tacInput.Name)); } } if (!StaticContext.ContainsGlobalKey(datatypeName)) { Contract.Assert(false, Error.MkErr(st, 12, datatypeName)); } var datatype = StaticContext.GetGlobal(datatypeName); if (datatype.TypeArgs != null) { _ctorTypes = new Dictionary <string, Type>(); if (datatype.TypeArgs.Count == datatypeType.TypeArgs.Count) { for (int i = 0; i < datatype.TypeArgs.Count; i++) { var genericType = datatype.TypeArgs[i]; var definedType = datatypeType.TypeArgs[i]; _ctorTypes.Add(genericType.Name, definedType); } } } if (isElement) { yield return(GenerateVerifiedStmt(datatype, casesGuard, st)); } else { foreach (var item in GenerateStmt(datatype, casesGuard, st)) { yield return(item); } } }
/// <summary> /// Get the value of local variable /// </summary> /// <param name="key"></param> /// <returns></returns> public object GetTacnyVarValue(NameSegment key) { Contract.Requires <ArgumentNullException>(key != null, "key"); Contract.Ensures(Contract.Result <object>() != null); return(GetTacnyVarValue(key.Name)); }
public override AssignmentRhs CloneRHS(AssignmentRhs rhs) { var r = rhs as ExprRhs; if (r != null && r.Expr is ApplySuffix) { var apply = (ApplySuffix)r.Expr; var mse = apply.Lhs.Resolved as MemberSelectExpr; if (mse != null && mse.Member is FixpointLemma && ModuleDefinition.InSameSCC(context, (FixpointLemma)mse.Member)) { // we're looking at a recursive call to a fixpoint lemma Contract.Assert(apply.Lhs is NameSegment || apply.Lhs is ExprDotName); // this is the only way a call statement can have been parsed // clone "apply.Lhs", changing the inductive/co lemma to the prefix lemma; then clone "apply", adding in the extra argument Expression lhsClone; if (apply.Lhs is NameSegment) { var lhs = (NameSegment)apply.Lhs; lhsClone = new NameSegment(Tok(lhs.tok), lhs.Name + "#", lhs.OptTypeArguments == null ? null : lhs.OptTypeArguments.ConvertAll(CloneType)); } else { var lhs = (ExprDotName)apply.Lhs; lhsClone = new ExprDotName(Tok(lhs.tok), CloneExpr(lhs.Lhs), lhs.SuffixName + "#", lhs.OptTypeArguments == null ? null : lhs.OptTypeArguments.ConvertAll(CloneType)); } var args = new List<Expression>(); args.Add(k); apply.Args.ForEach(arg => args.Add(CloneExpr(arg))); var applyClone = new ApplySuffix(Tok(apply.tok), lhsClone, args); var c = new ExprRhs(applyClone); reporter.Info(MessageSource.Cloner, apply.Lhs.tok, mse.Member.Name + suffix); return c; } } return base.CloneRHS(rhs); }
/// <summary> /// Check if Dafny key exists in the current context /// </summary> /// <param name="key">Variable</param> /// <returns>bool</returns> public bool ContainsVariable(NameSegment key) { Contract.Requires<ArgumentNullException>(tcce.NonNull(key)); return ContainsVariable(key.Name); }
private void AddVariant(Statement st, ref List <Solution> solution_list) { List <Expression> call_arguments = null; List <Expression> dec_list = null; Expression input = null; InitArgs(st, out call_arguments); Contract.Assert(tcce.OfSize(call_arguments, 1), Util.Error.MkErr(st, 0, 1, call_arguments.Count)); StringLiteralExpr wildCard = call_arguments[0] as StringLiteralExpr; if (wildCard != null) { if (wildCard.Value.Equals("*")) { input = new WildcardExpr(wildCard.tok); } } else { // hack /* * TODO: * Implement propper variable replacement */ object tmp; ProcessArg(call_arguments[0], out tmp); Contract.Assert(tmp != null); IVariable form = tmp as IVariable; if (form != null) { input = new NameSegment(form.Tok, form.Name, null); } else if (tmp is BinaryExpr) { input = tmp as BinaryExpr; } else if (tmp is NameSegment) { input = tmp as NameSegment; } } WhileStmt ws = FindWhileStmt(globalContext.tac_call, globalContext.md); if (ws != null) { WhileStmt nws = null; dec_list = new List <Expression>(ws.Decreases.Expressions.ToArray()); dec_list.Add(input); Specification <Expression> decreases = new Specification <Expression>(dec_list, ws.Attributes); nws = new WhileStmt(ws.Tok, ws.EndTok, ws.Guard, ws.Invariants, decreases, ws.Mod, ws.Body); AddUpdated(ws, nws); } else { Method target = Program.FindMember(globalContext.program.ParseProgram(), localContext.md.Name) as Method; if (GetNewTarget() != null && GetNewTarget().Name == target.Name) { target = GetNewTarget(); } Contract.Assert(target != null, Util.Error.MkErr(st, 3)); dec_list = target.Decreases.Expressions; // insert new variants at the end of the existing variants list Contract.Assert(input != null); dec_list.Add(input); Specification <Expression> decreases = new Specification <Expression>(dec_list, target.Decreases.Attributes); Method result = null; dynamic lemma = null; if ((lemma = target as Lemma) != null) { result = new Lemma(lemma.tok, lemma.Name, lemma.HasStaticKeyword, lemma.TypeArgs, lemma.Ins, lemma.Outs, lemma.Req, lemma.Mod, lemma.Ens, decreases, lemma.Body, lemma.Attributes, lemma.SignatureEllipsis); } else if ((lemma = target as CoLemma) != null) { result = new CoLemma(lemma.tok, lemma.Name, lemma.HasStaticKeyword, lemma.TypeArgs, lemma.Ins, lemma.Outs, lemma.Req, lemma.Mod, lemma.Ens, decreases, lemma.Body, lemma.Attributes, lemma.SignatureEllipsis); } else { result = new Method(target.tok, target.Name, target.HasStaticKeyword, target.IsGhost, target.TypeArgs, target.Ins, target.Outs, target.Req, target.Mod, target.Ens, decreases, target.Body, target.Attributes, target.SignatureEllipsis); } // register new method this.localContext.new_target = result; globalContext.program.IncTotalBranchCount(globalContext.program.currentDebug); } solution_list.Add(new Solution(this.Copy())); }
internal bool HasLocal(NameSegment key) { Contract.Requires<ArgumentNullException>(key != null, "key"); return HasLocal(key.Name); }
public override void Visit(NameSegment e) { }
public Type GetVariableType(NameSegment ns) { Contract.Requires(ns != null); return GetVariableType(ns.Name); }
public override void Leave(NameSegment e) { }
/// <summary> /// Check if Dafny key exists in the current context /// </summary> /// <param name="key">Variable</param> /// <returns>bool</returns> public bool ContainDafnyVar(NameSegment key) { Contract.Requires <ArgumentNullException>(Tcce.NonNull(key)); return(ContainDafnyVar(key.Name)); }
void NameSegment(out Expression e) { IToken id; IToken openParen = null; List<Type> typeArgs = null; List<Expression> args = null; Ident(out id); if (IsGenericInstantiation()) { typeArgs = new List<Type>(); GenericInstantiation(typeArgs); } else if (la.kind == 106) { HashCall(id, out openParen, out typeArgs, out args); } else if (StartOf(30)) { } else SynErr(231); e = new NameSegment(id, id.val, typeArgs); if (openParen != null) { e = new ApplySuffix(openParen, e, args); } }
/// <summary> /// Get the value of local variable /// </summary> /// <param name="key"></param> /// <returns></returns> public Expression GetTVarValue(NameSegment key) { Contract.Requires <ArgumentNullException>(key != null, "key"); Contract.Ensures(Contract.Result <Expression>() != null); return(GetTVarValue(key.Name)); }
void NameSegmentForTypeName(out Expression e) { IToken id; List<Type> typeArgs = null; Ident(out id); if (la.kind == 52) { typeArgs = new List<Type>(); GenericInstantiation(typeArgs); } e = new NameSegment(id, id.val, typeArgs); }
public Type GetVariableType(NameSegment ns) { Contract.Requires(ns != null); return(GetVariableType(ns.Name)); }
/// <summary> /// Deep copy nameSegment /// </summary> /// <param name="old"></param> /// <returns></returns> public static NameSegment CopyNameSegment(NameSegment old) { return(new NameSegment(old.tok, old.Name, old.OptTypeArguments)); }