void StatementRegions(Statement stmt, List <IdRegion> regions, Microsoft.Dafny.Program prog, ModuleDefinition module)
{
Contract.Requires(stmt != null);
Contract.Requires(regions != null);
Contract.Requires(prog != null);
IdRegion.AddRecognizedAttributes(stmt.Attributes, regions, prog);
if (stmt is VarDeclStmt)
{
var s = (VarDeclStmt)stmt;
// Add the variables here, once, and then go directly to the RHS's (without letting the sub-statements re-do the LHS's)
foreach (var local in s.Locals)
{
IdRegion.AddRecognizedAttributes(local.Attributes, regions, prog);
IdRegion.Add(regions, prog, local.Tok, local, true, (ICallable)null, module);
}
if (s.Update == null)
{
// the VarDeclStmt has no associated assignment
}
else if (s.Update is UpdateStmt)
{
var upd = (UpdateStmt)s.Update;
foreach (var rhs in upd.Rhss)
{
foreach (var ee in rhs.SubExpressions)
{
ExprRegions(ee, regions, prog, module);
}
if (rhs is TypeRhs)
{
CallStmt call = ((TypeRhs)rhs).InitCall;
if (call != null)
{
var method = call.Method;
if (method != null)
{
if (method is Constructor)
{
// call token starts at the beginning of "new C()", so we need to add 4 to the length.
RecordUseAndDef(prog, call.Tok, method.EnclosingClass.Name.Length + 4, method.EnclosingClass.tok);
}
else
{
RecordUseAndDef(prog, call.Tok, method.Name.Length, method.tok);
}
}
}
}
}
}
else
{
var upd = (AssignSuchThatStmt)s.Update;
ExprRegions(upd.Expr, regions, prog, module);
}
// we're done, so don't do the sub-statements/expressions again
return;
}
else if (stmt is LetStmt)
{
var s = (LetStmt)stmt;
foreach (var local in s.LHS.Vars)
{
IdRegion.Add(regions, prog, local.Tok, local, true, (ICallable)null, module);
}
}
else if (stmt is ForallStmt)
{
var s = (ForallStmt)stmt;
s.BoundVars.ForEach(bv => IdRegion.Add(regions, prog, bv.tok, bv, true, (ICallable)null, module));
}
else if (stmt is MatchStmt)
{
var s = (MatchStmt)stmt;
foreach (var kase in s.Cases)
{
kase.Arguments.ForEach(bv => {
IdRegion.Add(regions, prog, bv.tok, bv, true, (ICallable)null, module);
// if the arguments is an encapsulation of different boundvars from nested match cases,
// add the boundvars so that they can show up in the IDE correctly
if (bv.tok is MatchCaseToken)
{
MatchCaseToken mt = (MatchCaseToken)bv.tok;
foreach (Tuple <Bpl.IToken, BoundVar, bool> entry in mt.varList)
{
IdRegion.Add(regions, prog, entry.Item1, entry.Item2, entry.Item3, (ICallable)null, module);
}
}
});
}
}
else if (stmt is LoopStmt)
{
var s = (LoopStmt)stmt;
if (s.Mod.Expressions != null)
{
s.Mod.Expressions.ForEach(fe => FrameExprRegions(fe, regions, false, prog, module));
}
}
else if (stmt is CalcStmt)
{
var s = (CalcStmt)stmt;
// skip the last line, which is just a duplicate anyway
for (int i = 0; i < s.Lines.Count - 1; i++)
{
ExprRegions(s.Lines[i], regions, prog, module);
}
foreach (var ss in stmt.SubStatements)
{
StatementRegions(ss, regions, prog, module);
}
return;
}
else if (stmt is CallStmt)
{
var s = (CallStmt)stmt;
var method = s.Method;
if (method != null)
{
RecordUseAndDef(prog, s.MethodSelect.tok, method.Name.Length, method.tok);
}
}
foreach (var ee in stmt.SubExpressions)
{
ExprRegions(ee, regions, prog, module);
}
foreach (var ss in stmt.SubStatements)
{
StatementRegions(ss, regions, prog, module);
}
}
static void ExprRegions(Microsoft.Dafny.Expression expr, List <IdRegion> regions, Microsoft.Dafny.Program prog, ModuleDefinition module)
{
Contract.Requires(expr != null);
Contract.Requires(regions != null);
Contract.Requires(prog != null);
if (expr is AutoGeneratedExpression)
{
// do nothing
return;
}
else if (expr is IdentifierExpr)
{
var e = (IdentifierExpr)expr;
IdRegion.Add(regions, prog, e.tok, e.Var, false, module);
}
else if (expr is MemberSelectExpr)
{
var e = (MemberSelectExpr)expr;
var field = e.Member as Field;
if (field != null)
{
IdRegion.Add(regions, prog, e.tok, field, e.Type, "field", false, module);
}
}
else if (expr is LetExpr)
{
var e = (LetExpr)expr;
IdRegion.AddRecognizedAttributes(e.Attributes, regions, prog);
foreach (var bv in e.BoundVars)
{
IdRegion.Add(regions, prog, bv.tok, bv, true, module);
}
}
else if (expr is ComprehensionExpr)
{
var e = (ComprehensionExpr)expr;
IdRegion.AddRecognizedAttributes(e.Attributes, regions, prog);
foreach (var bv in e.BoundVars)
{
IdRegion.Add(regions, prog, bv.tok, bv, true, module);
}
}
else if (expr is MatchExpr)
{
var e = (MatchExpr)expr;
foreach (var kase in e.Cases)
{
kase.Arguments.ForEach(bv => {
IdRegion.Add(regions, prog, bv.tok, bv, true, module);
// if the arguments is an encapsulation of different boundvars from nested match cases,
// add the boundvars so that they can show up in the IDE correctly
if (bv.tok is MatchCaseToken)
{
MatchCaseToken mt = (MatchCaseToken)bv.tok;
foreach (Tuple <Bpl.IToken, BoundVar, bool> entry in mt.varList)
{
IdRegion.Add(regions, prog, entry.Item1, entry.Item2, entry.Item3, module);
}
}
});
}
}
else if (expr is ChainingExpression)
{
var e = (ChainingExpression)expr;
// Do the subexpressions only once (that is, avoid the duplication that occurs in the desugared form of the ChainingExpression)
e.Operands.ForEach(ee => ExprRegions(ee, regions, prog, module));
return; // return here, so as to avoid doing the subexpressions below
}
foreach (var ee in expr.SubExpressions)
{
ExprRegions(ee, regions, prog, module);
}
}
void ExprRegions(Microsoft.Dafny.Expression expr, List <IdRegion> regions, Microsoft.Dafny.Program prog, ModuleDefinition module)
{
Contract.Requires(expr != null);
Contract.Requires(regions != null);
Contract.Requires(prog != null);
if (expr is AutoGeneratedExpression)
{
// do nothing
return;
}
else if (expr is IdentifierExpr)
{
var e = (IdentifierExpr)expr;
IdRegion.Add(regions, prog, e.tok, e.Var, false, (ICallable)null, module);
}
else if (expr is MemberSelectExpr)
{
var e = (MemberSelectExpr)expr;
var field = e.Member as Field;
if (field != null)
{
var kind = !(field is ConstantField) ? "field" : field.IsStatic && !(field.EnclosingClass is DefaultClassDecl) ? "static const" : "const";
IdRegion.Add(regions, prog, e.tok, field, e.Type, kind, false, module);
}
if (e.Member != null)
{
RecordUseAndDef(prog, e.tok, e.Member.Name.Length, e.Member.tok);
}
}
else if (expr is FunctionCallExpr)
{
var e = (FunctionCallExpr)expr;
var func = e.Function;
if (func != null)
{
RecordUseAndDef(prog, e.tok, func.Name.Length, func.tok);
}
}
else if (expr is ApplySuffix)
{
// No need to call ExprRegions on the Lhs field because the for loop at the end of this function will do that.
}
else if (expr is LetExpr)
{
var e = (LetExpr)expr;
IdRegion.AddRecognizedAttributes(e.Attributes, regions, prog);
foreach (var bv in e.BoundVars)
{
IdRegion.Add(regions, prog, bv.tok, bv, true, (ICallable)null, module);
}
}
else if (expr is ComprehensionExpr)
{
var e = (ComprehensionExpr)expr;
IdRegion.AddRecognizedAttributes(e.Attributes, regions, prog);
foreach (var bv in e.BoundVars)
{
IdRegion.Add(regions, prog, bv.tok, bv, true, (ICallable)null, module);
}
if (expr is QuantifierExpr)
{
// If the quantifier has a SplitQuantifier, then its .SubExpressions routine goes over each split.
// That's not what we want here, because it would cause duplicated hover texts. Instead, we just
// do what a QuantifierExpr would do without a SplitQuantifier, which is as follows:
foreach (var ee in Attributes.SubExpressions(e.Attributes))
{
ExprRegions(ee, regions, prog, module);
}
if (e.Range != null)
{
ExprRegions(e.Range, regions, prog, module);
}
ExprRegions(e.Term, regions, prog, module);
return;
}
}
else if (expr is MatchExpr)
{
var e = (MatchExpr)expr;
foreach (var kase in e.Cases)
{
kase.Arguments.ForEach(bv => {
IdRegion.Add(regions, prog, bv.tok, bv, true, (ICallable)null, module);
// if the arguments is an encapsulation of different boundvars from nested match cases,
// add the boundvars so that they can show up in the IDE correctly
if (bv.tok is MatchCaseToken)
{
MatchCaseToken mt = (MatchCaseToken)bv.tok;
foreach (Tuple <Bpl.IToken, BoundVar, bool> entry in mt.varList)
{
IdRegion.Add(regions, prog, entry.Item1, entry.Item2, entry.Item3, (ICallable)null, module);
}
}
});
}
}
else if (expr is ChainingExpression)
{
var e = (ChainingExpression)expr;
// Do the subexpressions only once (that is, avoid the duplication that occurs in the desugared form of the ChainingExpression)
e.Operands.ForEach(ee => ExprRegions(ee, regions, prog, module));
return; // return here, so as to avoid doing the subexpressions below
}
foreach (var ee in expr.SubExpressions)
{
ExprRegions(ee, regions, prog, module);
}
}
static void StatementRegions(Statement stmt, List <IdRegion> regions, Microsoft.Dafny.Program prog, ModuleDefinition module)
{
Contract.Requires(stmt != null);
Contract.Requires(regions != null);
Contract.Requires(prog != null);
if (stmt is VarDeclStmt)
{
var s = (VarDeclStmt)stmt;
// Add the variables here, once, and then go directly to the RHS's (without letting the sub-statements re-do the LHS's)
foreach (var local in s.Locals)
{
IdRegion.Add(regions, prog, local.Tok, local, true, module);
}
if (s.Update == null)
{
// the VarDeclStmt has no associated assignment
}
else if (s.Update is UpdateStmt)
{
var upd = (UpdateStmt)s.Update;
foreach (var rhs in upd.Rhss)
{
foreach (var ee in rhs.SubExpressions)
{
ExprRegions(ee, regions, prog, module);
}
}
}
else
{
var upd = (AssignSuchThatStmt)s.Update;
ExprRegions(upd.Expr, regions, prog, module);
}
// we're done, so don't do the sub-statements/expressions again
return;
}
else if (stmt is ForallStmt)
{
var s = (ForallStmt)stmt;
s.BoundVars.ForEach(bv => IdRegion.Add(regions, prog, bv.tok, bv, true, module));
}
else if (stmt is MatchStmt)
{
var s = (MatchStmt)stmt;
foreach (var kase in s.Cases)
{
kase.Arguments.ForEach(bv => {
IdRegion.Add(regions, prog, bv.tok, bv, true, module);
// if the arguments is an encapsulation of different boundvars from nested match cases,
// add the boundvars so that they can show up in the IDE correctly
if (bv.tok is MatchCaseToken)
{
MatchCaseToken mt = (MatchCaseToken)bv.tok;
foreach (Tuple <Bpl.IToken, BoundVar, bool> entry in mt.varList)
{
IdRegion.Add(regions, prog, entry.Item1, entry.Item2, entry.Item3, module);
}
}
});
}
}
else if (stmt is LoopStmt)
{
var s = (LoopStmt)stmt;
if (s.Mod.Expressions != null)
{
s.Mod.Expressions.ForEach(fe => FrameExprRegions(fe, regions, false, prog, module));
}
}
else if (stmt is CalcStmt)
{
var s = (CalcStmt)stmt;
// skip the last line, which is just a duplicate anyway
for (int i = 0; i < s.Lines.Count - 1; i++)
{
ExprRegions(s.Lines[i], regions, prog, module);
}
foreach (var ss in stmt.SubStatements)
{
StatementRegions(ss, regions, prog, module);
}
return;
}
foreach (var ee in stmt.SubExpressions)
{
ExprRegions(ee, regions, prog, module);
}
foreach (var ss in stmt.SubStatements)
{
StatementRegions(ss, regions, prog, module);
}
}
