public Expression visit(QuantifiedTypeExpression e)
{
addExpression(e);
tqStack.Push(new TQ(e));
Expression ee = e.expression;
while (true)
{
var qte = ee as QuantifiedTypeExpression;
if (qte != null)
{
ee = qte.expression;
}
else
{
break;
}
}
ee.visit(this);
TQ tq = tqStack.Pop();
tqList.Add(tq);
return(e);
}
public override Expression visit(QuantifiedTypeExpression e)
{
context.Push(e.ToString());
base.visit(e);
context.Pop();
// addSubexpression(result,context.Peek());
return(e);
}
public override String ToString()
{
Expression se = expression;
var typeVars = new List <TypeVariable>();
QuantifiedTypeExpression qte = this;
while (qte != null && qte.quantifier == quantifier)
{
typeVars.Add(qte.variable);
se = qte.expression;
qte = se as QuantifiedTypeExpression;
}
string result = "";
{
result = quantifier.ToString() + "<";
for (int i = 0; i < typeVars.Count; i++)
{
result += (i == 0 ? "" : ",") + typeVars[i].name;
}
result += ">";
}
var qe = se as QuantifiedExpression;
if (qe != null && matches(quantifier, qe.quantifier))
{
result += qe.ToStringSansQuantifier();
}
else
{
result += " :: ";
if (triggers.count > 0)
{
result += "{";
for (int i = 0; i < triggers.count; i++)
{
result += (i == 0 ? "" : ",") + triggers[i].ToString();
}
result += "} ";
}
if (attributes != null)
{
result += attributes;
}
result += se.ToString();
}
return("(" + result + ")");
}
//////////////////////////////////////////////
///////////////////////////////////////////////////////////
public BasicQuantifiedTypeExpression(
QuantifiedTypeExpression other,
ExpressionSubstitution s
)
{
quantifier = other.quantifier;
variable = new BasicTypeVariable(getFreshTypeVariableName());
s.typeSubstitution.add(other.variable, new VariableType(variable));
expression = other.expression.substitute(s);
triggers = new ExpressionList(other.triggers);
attributes = other.attributes;
s.typeSubstitution.remove(other.variable);
}
public virtual Expression visit(QuantifiedTypeExpression e)
{
TypeVariable newV = visitTypeVariable(e.variable);
Expression newE = e.expression.visit(this);
ExpressionList newT = e.triggers.visit(this);
Expression result;
if (!ReferenceEquals(e.variable, newV) || !ReferenceEquals(e.expression, newE) ||
!ReferenceEquals(e.triggers, newT))
{
result = new BasicQuantifiedTypeExpression(e.quantifier, newV, newE, newT, e.attributes);
}
else
{
result = e;
}
return(result);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private Expression removeTypeQuantification(QuantifiedTypeExpression qte)
{
Expression e = qte.expression;
while (e is QuantifiedTypeExpression)
{
e = (e as QuantifiedTypeExpression).expression;
}
#if DEBUG // Console.WriteLine("Removing type quantification {0}", qte.ToString());
{
var tvs = new HashSet <TypeVariable>();
Expression qe = qte;
while (qe is QuantifiedTypeExpression)
{
tvs.Add((qe as QuantifiedTypeExpression).variable);
qe = (qe as QuantifiedTypeExpression).expression;
}
var qvs = new List <BoundVariable>();
var ee = e;
while (ee is QuantifiedExpression)
{
var qqe = ee as QuantifiedExpression;
qvs.Add(qqe.variable);
ee = qqe.expression;
}
var gqvs = (from qv in qvs where !qv.type.freeTypeVariables.Intersect(tvs).Any() select qv).ToArray();
// if (gqvs.Any())
// Debugger.Break();
}
#endif
Function connective = (qte.quantifier is TypeForall) ? BFunction.and : BFunction.or;
bool zeroValue = (qte.quantifier is TypeForall) ? true : false;
return(openQuantifier(e, connective, zeroValue));
}
public TQ(QuantifiedTypeExpression e)
{
this.e = e;
}
public Expression visit(QuantifiedTypeExpression e)
{
e.expression.visit(this);
return(e);
}
public override Expression visit(QuantifiedTypeExpression e)
{
Expression result = checkReplace(base.visit(e));
return(result);
}
public Expression visit(QuantifiedTypeExpression e)
{
return(e);
}
