private static bool ShallowEq(MemberSelectExpr expr1, MemberSelectExpr expr2)
{
return(expr1.MemberName == expr2.MemberName &&
expr1.Member == expr2.Member &&
TriggerUtils.SameLists(expr1.TypeApplication_AtEnclosingClass, expr2.TypeApplication_AtEnclosingClass, TypeEq) &&
TriggerUtils.SameLists(expr1.TypeApplication_JustMember, expr2.TypeApplication_JustMember, TypeEq));
}
public override void Visit(ExprDotName e)
{
MemberSelectExpr mse = null;
if (e.ResolvedExpression is MemberSelectExpr)
{
mse = e.ResolvedExpression as MemberSelectExpr;
}
var nav = new SymbolNavigator();
var definingItem = nav.TopDown(RootNode, mse?.Member.tok);
var declaration = FindDeclaration(e.SuffixName, definingItem);
CreateSymbol(
name: e.SuffixName,
kind: null,
type: e.Type,
positionAsToken: e.tok,
bodyStartPosAsToken: null,
bodyEndPosAsToken: null,
isDeclaration: false,
declarationSymbol: declaration,
addUsageAtDeclaration: true,
canHaveChildren: false,
canBeUsed: false
);
}
public string GenerateConditionString(MemberSelectExpr expression, IDictionary <string, string> rename)
{
var left = GenerateConditionString(expression.Obj, rename);
var dot = ".";
var member = expression.MemberName;
return(left + dot + member);
}
void TrMemberSelectExpr(MemberSelectExpr e)
{
Contract.Requires(e != null);
SpecialField sf = e.Member as SpecialField;
if (sf != null && (sf.PostString != "" || sf.PreString != "")) {
// A SpecialField with no Pre- or Post- string generates identical
// code to a non-SpecialField, except for parentheses. For Kremlin,
// the code-gen is identical in that case.
WriteEAbort("BUGBUG MemberSelectExpr TrExpr if SpecialField not supported"); // bugbug: implement
}
else {
using (WriteArray()) {
// e.Member.Name is the field name
// e.Obj.Name is the struct name
j.WriteValue(KremlinAst.EField);
using (WriteArray()) { // of (lident * expr * ident)
WriteLident(e.Obj.Type);
using (WriteArray()) {
j.WriteValue(KremlinAst.EBufRead);
using (WriteArray()) {
TrExpr(e.Obj, false); // This will generate an EBound reference to the variable
WriteConstant(0u);
}
}
j.WriteValue(e.Member.Name);
}
}
}
}
public Tuple<Method,TypeApply> GetSeqBuildMethod(Type t, SeqTree tree, List<bool> elemDimensions)
{
if (elemDimensions.Count == 0)
{
return GetSeqMethod(t, "seq_Empty");
}
if (elemDimensions.Count == 2 && elemDimensions[0] && elemDimensions[1])
{
return GetSeqMethod(t, "seq_Append");
}
string op = "seq_" + SeqTree.TreeName(tree);
DatatypeDecl seqDecl = FindDatatype("Seq");
var tok = new Bpl.Token(0, 0);
tok.filename = @"!\Seq.dfy";
TypeApply tApp = Compile_SeqType((SeqType)t);
Type dataType = new UserDefinedType(tok, "Seq", seqDecl, new List<Type> { ((SeqType)t).Arg });
Type elemType = ((SeqType)t).Arg;
Func<string,Type,Expression> idExpr = (x, typ) => {
var e = new IdentifierExpr(tok, x);
e.Type = typ;
e.Var = new LocalVariable(tok, tok, x, typ, false);
return e;
};
Func<string,List<Expression>,FunctionCallExpr> seqCall = (x, args) => {
var seqOp = GetSeqOperation(t, x);
FunctionCallExpr callExpr = new FunctionCallExpr(
tok, "Seq_Empty", new ThisExpr(tok), tok, args);
callExpr.Function = seqOp.Item1;
callExpr.TypeArgumentSubstitutions = seqOp.Item2.typeArgs;
return callExpr;
};
Expression empty = seqCall("Seq_Empty", new List<Expression> {});
int varCount = 0;
Func<SeqTree,Expression> resultRec = null;
resultRec = (subtree) =>
{
if (subtree == null)
{
return idExpr("s" + (varCount++), dataType);
}
if (subtree.buildCount >= 0)
{
Expression build = empty;
for (int i = 0; i < subtree.buildCount; i++)
{
build = seqCall("Seq_Build", new List<Expression>
{ build, idExpr("a" + (varCount++), elemType) });
}
return build;
}
else
{
return seqCall("Seq_Append", new List<Expression>
{ resultRec(subtree.left), resultRec(subtree.right) });
}
};
Expression result = resultRec(tree);
Expression post = seqCall("Seq_Equal", new List<Expression> { idExpr("s", dataType), result });
List<Statement> stmts = new List<Statement>();
for (int i = elemDimensions.Count; i > 0;)
{
bool isFirst = (i == elemDimensions.Count);
i--;
if (elemDimensions[i])
{
if (isFirst)
{
stmts.Add(new AssignStmt(tok, tok, idExpr("s", dataType),
new ExprRhs(idExpr("s" + i, dataType))));
}
else
{
// s := seq_Append(s9, s);
var selectExpr = new MemberSelectExpr(tok, new ThisExpr(tok), "seq_Append");
selectExpr.Member = FindMethod(selectExpr.MemberName); // Manually resolve here
selectExpr.TypeApplication = new List<Type>() { elemType }; // Manually resolve here
selectExpr.Type = new InferredTypeProxy(); // Manually resolve here
CallStmt callStmt = new CallStmt(tok, tok,
new List<Expression> {idExpr("s", dataType)},
selectExpr, new List<Expression>
{ idExpr("s" + i, dataType), idExpr("s", dataType) });
stmts.Add(callStmt);
}
}
else
{
if (isFirst)
{
DatatypeValue nil = new DatatypeValue(tok, "Seq", "Nil", new List<Expression>() {});
nil.Type = dataType;
nil.InferredTypeArgs = new List<Type> { elemType };
nil.Ctor = seqDecl.Ctors[0];
Util.Assert(nil.Ctor.Name == "Seq_Nil");
stmts.Add(new AssignStmt(tok, tok, idExpr("s", dataType), new ExprRhs(nil)));
}
// lemma_Seq_Cons(ai, s);
var selectExpr = new MemberSelectExpr(tok, new ThisExpr(tok), "lemma_Seq_Cons");
selectExpr.Member = FindMethod(selectExpr.MemberName); // Manually resolve here
selectExpr.TypeApplication = new List<Type>() { elemType }; // Manually resolve here
selectExpr.Type = new InferredTypeProxy(); // Manually resolve here
CallStmt callStmt = new CallStmt(tok, tok,
new List<Expression> {},
selectExpr, new List<Expression>
{ idExpr("a" + i, elemType), idExpr("s", dataType) });
callStmt.IsGhost = true;
stmts.Add(callStmt);
DatatypeValue cons = new DatatypeValue(tok, "Seq", "Cons", new List<Expression>()
{ idExpr("a" + i, elemType), idExpr("s", dataType) });
cons.Type = dataType;
cons.InferredTypeArgs = new List<Type> { elemType };
cons.Ctor = seqDecl.Ctors[1];
Util.Assert(cons.Ctor.Name == "Seq_Cons");
stmts.Add(new AssignStmt(tok, tok, idExpr("s", dataType), new ExprRhs(cons)));
}
}
BlockStmt body = new BlockStmt(tok, tok, stmts);
List<Formal> ins = new List<Formal>();
for (int i = 0; i < elemDimensions.Count; i++)
{
bool isSeq = elemDimensions[i];
ins.Add(new Formal(tok, (isSeq ? "s" : "a") + i, isSeq ? dataType : elemType, true, false));
}
List<Formal> outs = new List<Formal> { new Formal(tok, "s", dataType, false, false) };
List<MaybeFreeExpression> reqs = new List<MaybeFreeExpression>();
List<MaybeFreeExpression> enss = new List<MaybeFreeExpression> { new MaybeFreeExpression(post) };
Specification<FrameExpression> mods = new Specification<FrameExpression>(new List<FrameExpression>(), null);
Specification<Expression> decs = new Specification<Expression>(new List<Expression>(), null);
Attributes attrs = new Attributes("dafnycc_conservative_seq_triggers", new List<Expression>(), null);
Method m = new Method(tok, op, true, false, tApp.typeParams, ins, outs, reqs, mods, enss, decs, body, attrs, tok);
m.EnclosingClass = GetSeqMethod(t, "seq_Append").Item1.EnclosingClass;
return Tuple.Create(m, Compile_Method(m, tApp.typeArgs));
}
public override void Compile_FunctionAsMethod(Function function, Dictionary<TypeParameter,Type> typeArgs,
Dictionary<string,TypeParameter> substArgs)
{
var tok = function.tok;
if (Attributes.Contains(function.Attributes, "CompiledSpec"))
{
string specName = function.Name.Substring("CompiledSpec_".Length);
function = FindFunction(specName);
}
bool hidden = Attributes.Contains(function.Attributes, "opaque");
Formal result = new Formal(function.tok, "__result", function.ResultType, false, function.IsGhost);
string funName = function.Name;
string name = FunName(DafnySpec.SimpleSanitizedName(function));
FunctionCallExpr call = new FunctionCallExpr(tok, name, new ThisExpr(tok), tok,
function.Formals.ConvertAll(f => (Expression)
MakeIdentifierExpr(f.Name, f.Type, f.IsGhost)));
call.Function = function;
call.TypeArgumentSubstitutions = typeArgs;
call.Type = function.ResultType;
CallStmt revealCall = null;
if (hidden)
{
var selectExpr = new MemberSelectExpr(tok, new ThisExpr(tok), "reveal_" + function.Name);
selectExpr.Member = FindMethod(selectExpr.MemberName); // Manually resolve here
selectExpr.TypeApplication = new List<Type>(); // Manually resolve here
selectExpr.Type = new InferredTypeProxy(); // Manually resolve here
revealCall = new CallStmt(tok, tok, new List<Expression>(), selectExpr, new List<Expression>());
revealCall.IsGhost = true;
ClassDecl cls = (ClassDecl)function.EnclosingClass;
string fullName = "#" + function.Name + "_FULL";
function = (Function)cls.Members.Find(m => m.Name == fullName);
if (function == null)
{
throw new Exception("internal error: could not find function " + fullName);
}
substArgs = new Dictionary<string,TypeParameter>();
function.TypeArgs.ForEach(t => substArgs.Add(t.Name, t));
typeArgs = typeArgs.ToDictionary(p => substArgs[p.Key.Name], p => p.Value);
}
Expression funBody = function.Body;
BlockStmt body = null;
if (funBody != null)
{
ReturnStmt retStmt = new ReturnStmt(tok, tok, new List<AssignmentRhs>() {
new ExprRhs(funBody)
});
body = new BlockStmt(tok, tok,
hidden
? (new List<Statement>() { revealCall, retStmt })
: (new List<Statement>() { retStmt }));
}
List<Expression> ens = new List<Expression> {
MakeBinaryExpr(BinaryExpr.Opcode.Eq, BinaryExpr.ResolvedOpcode.EqCommon, Type.Bool,
MakeIdentifierExpr("__result", function.ResultType, function.IsGhost),
call)
}.Concat(function.Ens).ToList();
Method method = new Method(tok, funName, function.IsStatic, function.IsGhost,
function.TypeArgs, function.Formals, new List<Formal> { result },
function.Req.ConvertAll(e => new MaybeFreeExpression(e)),
new Specification<FrameExpression>(new List<FrameExpression>(), null),
ens.ConvertAll(e => new MaybeFreeExpression(e)),
function.Decreases,
body, function.Attributes, function.SignatureEllipsis);
method.EnclosingClass = function.EnclosingClass;
Compile_Method(method, typeArgs);
}
public string GenerateString(MemberSelectExpr expression)
{
return(expression.Obj.tok.val + "." + expression.MemberName);
}
private static bool ShallowEq(MemberSelectExpr expr1, MemberSelectExpr expr2)
{
return(expr1.MemberName == expr2.MemberName &&
expr1.Member == expr2.Member &&
TriggerUtils.SameLists(expr1.TypeApplication, expr2.TypeApplication, Microsoft.Dafny.Type.Equals));
}
private static bool ShallowEq(MemberSelectExpr expr1, MemberSelectExpr expr2)
{
return(expr1.MemberName == expr2.MemberName &&
expr1.Member == expr2.Member &&
TriggerUtils.SameLists(expr1.TypeApplication, expr2.TypeApplication, TypeEq));
}
List <Expression> GenerateAutoReqs(Expression expr, Function parent)
{
List <Expression> reqs = new List <Expression>();
Func <Expression, List <Expression> > generateAutoReqs = e => GenerateAutoReqs(e, parent);
if (expr is LiteralExpr)
{
}
else if (expr is ThisExpr)
{
}
else if (expr is IdentifierExpr)
{
}
else if (expr is SeqDisplayExpr)
{
SeqDisplayExpr e = (SeqDisplayExpr)expr;
foreach (var elt in e.Elements)
{
reqs.AddRange(generateAutoReqs(elt));
}
}
else if (expr is MemberSelectExpr && ((MemberSelectExpr)expr).Member is Field)
{
MemberSelectExpr e = (MemberSelectExpr)expr;
reqs.AddRange(generateAutoReqs(e.Obj));
}
else if (expr is SeqSelectExpr)
{
SeqSelectExpr e = (SeqSelectExpr)expr;
reqs.AddRange(generateAutoReqs(e.Seq));
if (e.E0 != null)
{
reqs.AddRange(generateAutoReqs(e.E0));
}
if (e.E1 != null)
{
reqs.AddRange(generateAutoReqs(e.E1));
}
}
else if (expr is SeqUpdateExpr)
{
SeqUpdateExpr e = (SeqUpdateExpr)expr;
reqs.AddRange(generateAutoReqs(e.Seq));
reqs.AddRange(generateAutoReqs(e.Index));
reqs.AddRange(generateAutoReqs(e.Value));
}
else if (expr is FunctionCallExpr)
{
FunctionCallExpr e = (FunctionCallExpr)expr;
foreach (var arg in e.Args)
{
reqs.AddRange(generateAutoReqs(arg));
}
if (parent == null || parent.Name != e.name)
{
ReqFunction(e.Function);
reqs.AddRange(GatherReqs(e.Function, e.Args));
}
}
else if (expr is DatatypeValue)
{
DatatypeValue dtv = (DatatypeValue)expr;
for (int i = 0; i < dtv.Arguments.Count; i++)
{
Expression arg = dtv.Arguments[i];
reqs.AddRange(generateAutoReqs(arg));
}
}
else if (expr is OldExpr)
{
}
else if (expr is MatchExpr)
{
MatchExpr e = (MatchExpr)expr;
reqs.AddRange(generateAutoReqs(e.Source));
List <MatchCaseExpr> newMatches = new List <MatchCaseExpr>();
foreach (MatchCaseExpr caseExpr in e.Cases)
{
MatchCaseExpr c = new MatchCaseExpr(caseExpr.name, caseExpr.Arguments, Andify(generateAutoReqs(caseExpr.Body)));
newMatches.Add(c);
}
reqs.Add(new MatchExpr(e.Source, newMatches));
}
else if (expr is UnaryOpExpr)
{
UnaryOpExpr e = (UnaryOpExpr)expr;
Expression arg = e.E;
reqs.AddRange(generateAutoReqs(arg));
}
else if (expr is BinaryExpr)
{
BinaryExpr e = (BinaryExpr)expr;
switch (e.Op)
{
case BinaryExpr.Opcode.Imp:
case BinaryExpr.Opcode.And:
reqs.AddRange(generateAutoReqs(e.E0));
foreach (var req in generateAutoReqs(e.E1))
{
reqs.Add(new BinaryExpr(Token.NoToken, BinaryExpr.Opcode.Imp, e.E0, req));
}
break;
case BinaryExpr.Opcode.Or:
reqs.AddRange(generateAutoReqs(e.E0));
foreach (var req in generateAutoReqs(e.E1))
{
reqs.Add(new BinaryExpr(Token.NoToken, BinaryExpr.Opcode.Imp,
new UnaryOpExpr(Token.NoToken, UnaryOpExpr.Opcode.Not, e.E0), req));
}
break;
default:
reqs.AddRange(generateAutoReqs(e.E0));
reqs.AddRange(generateAutoReqs(e.E1));
break;
}
}
else if (expr is LetExpr)
{
var e = (LetExpr)expr;
if (e.Exact)
{
foreach (var rhs in e.RHSs)
{
reqs.AddRange(generateAutoReqs(rhs));
}
var new_reqs = generateAutoReqs(e.Body);
if (new_reqs.Count > 0)
{
reqs.Add(new LetExpr(e.Exact, e.LHSs, e.RHSs, Andify(new_reqs)));
}
}
}
else if (expr is QuantifierExpr)
{
QuantifierExpr e = (QuantifierExpr)expr;
var auto_reqs = generateAutoReqs(e.Term);
if (auto_reqs.Count > 0)
{
Expression allReqsSatisfied = Andify(auto_reqs);
Expression allReqsSatisfiedAndTerm = new BinaryExpr(Token.NoToken, BinaryExpr.Opcode.And, allReqsSatisfied, e.Term);
e.Term = allReqsSatisfiedAndTerm;
}
}
else if (expr is StmtExpr)
{
var e = (StmtExpr)expr;
reqs.AddRange(generateAutoReqs(e.E));
}
else if (expr is ITEExpr)
{
ITEExpr e = (ITEExpr)expr;
reqs.AddRange(generateAutoReqs(e.Test));
reqs.Add(new ITEExpr(e.Test, Andify(generateAutoReqs(e.Thn)), Andify(generateAutoReqs(e.Els))));
}
return(reqs);
}
