public override Function substitute(TypeParameterInstantiation s)
{
return(new BasicFunctionTemplateInstance(
template,
(from a in typeArguments select a.substitute(s)).ToArray()
));
}
private TypeConstructorInstance substituteOriginalType(TypeParameterInstantiation instantiation)
{
if (originalType == null)
{
return(null);
}
return(originalType.substitute(instantiation) as TypeConstructorInstance);
}
public Function substitute(TypeParameterInstantiation s)
{
return(makeMapWrite(
(from a in mapTypeArguments select a.substitute(s)).ToArray(),
(from a in argumentTypes select a.substitute(s)).ToArray(),
resultType.substitute(s)
));
}
public Function substitute(TypeParameterInstantiation s)
{
return(new BasicMapRead(
mapType.substituteMap(s),
(from ta in mapTypeArguments select ta.substitute(s)).ToArray(),
(from it in mapIndexTypes select it.substitute(s)).ToArray(),
resultType.substitute(s)
));
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
public IType substitute(TypeParameterInstantiation instantiation)
{
IType result = instantiation.map(typeVariable);
if (result == null)
{
result = this;
}
return(result);
}
public static BasicMapRead mapRead(MapType mapType, ITypeTuple typeArguments)
{
Debug.Assert(mapType != null);
Debug.Assert(typeArguments != null);
Debug.Assert(mapType.typeParameters.Length == typeArguments.Count());
var s = new TypeParameterInstantiation(mapType.typeParameters, typeArguments);
var argumentTypes = TypeTuple.make(new [] { mapType }.Concat(from a in mapType.domain select a.substitute(s)));
var resultType = mapType.range.substitute(s);
return(mapRead(typeArguments, argumentTypes, resultType));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
public MapType substituteMap(TypeParameterInstantiation instantiation)
{
foreach (var tp in typeParameters)
{
Debug.Assert(instantiation.map(tp) == null);
}
// Debug.Assert(mapTypeArguments.Length == mapTypeArguments.Length);
bool clone = false;
var newDomain = new IType[domain.Count()];
for (int i = 0; i < domain.Count(); i++)
{
newDomain[i] = domain[i].substitute(instantiation);
if (newDomain[i] != domain[i])
{
clone = true;
}
}
IType newRange = range.substitute(instantiation);
if (newRange != range)
{
clone = true;
}
TypeConstructorInstance newOriginalType = substituteOriginalType(instantiation);
if (newOriginalType != originalType)
{
clone = true;
}
MapType result;
if (clone)
{
result = new MapType((TypeVariable[])typeParameters.Clone(), newDomain, newRange, newOriginalType);
result.originalSubstitution = this;
}
else
{
result = this;
}
return(result);
}
private Expression makeMapWriteMap(FAE fae)
{
Debug.Assert(fae.function is MapWrite);
Debug.Assert(fae.arguments[0].type is MapType);
var mu = fae.function as MapWrite;
Expression result;
if (!versionMap.TryGetValue(fae.ToString(), out result))
{
var ot = fae.arguments[0].type as MapType;
Debug.Assert(ot != null);
var s = new TypeParameterInstantiation(ot.typeParameters, mu.typeArguments.Skip(1).ToArray());
// var ots = new MapType(new TypeVariable[0], (from m in ot.domain select m.substitute(s)).ToArray(), ot.range.substitute(s));
Expression m = fae.arguments[0];
Expression[] i = fae.arguments.Take(fae.arguments.count - 1).Skip(1).ToArray();
if (fae.freeVariables.Count > 0)
{
//m(fv)[i(fv):=x(fv)] ==> v(fv) (assume v(fv)[i]==x, assume forall fv : forall j : j!=i(fv) ==> v(fv)[j] == m(fv)[j]
var fvt = TypeTuple.make(from fv in fae.freeVariables select fv.type);
string fn = getFreshMUName("mu");
var ft = new BFunctionTemplate(fn, "", new TypeVariable[0], new BasicFunctionSignature(ot, fvt),
null);
Function f = ft.getInstance();
IEnumerable <BasicBoundVariableExpression> fve = from fv in fae.freeVariables
select new BasicBoundVariableExpression(fv);
result = new BasicFAE(f, new ExpressionList(fve));
}
else
{
//m[i:=x] ==> v (assume v[i]==x, assume forall j : j!=i ==> v[j] == m[j]
string nvn = getFreshMUName("mu");
var nv = new ProgramVariable(nvn, ot, false, false, false, false);
procedure.addVariable(nv);
result = new BasicProgramVariableExpression(nv);
}
Expression[] j =
(from e in i select new BasicBoundVariableExpression(makeBoundVariable(e.type))).ToArray();
//forall j : j!=i ==> v[j]==m[j]
addConditionalMapEqualityAxiom(i, result, m, mu.typeArguments);
//v[i]==x;
Expression x = fae.arguments.Last();
addEqualityAxiom(ml(result, i, mu.typeArguments.Skip(1).ToArray(), x.type), fae.arguments.Last());
}
return(result);
}
public static BasicMapRead mapRead(IEnumerable <IType> typeArguments, IEnumerable <IType> argumentTypes, IType resultType)
{
Debug.Assert(typeArguments != null);
Debug.Assert(argumentTypes != null);
Debug.Assert(argumentTypes.Count() > 0);
var mapType = argumentTypes.First() as MapType;
Debug.Assert(mapType != null);
Debug.Assert(typeArguments.Count() == mapType.typeParameters.Length);
Debug.Assert(mapType.domain.Count() == argumentTypes.Count() - 1);
var substitution = new TypeParameterInstantiation(mapType.typeParameters, typeArguments);
IType sresultType = mapType.range.substitute(substitution);
Debug.Assert(resultType.ToStringN() == sresultType.ToStringN());
Debug.Assert(argumentTypes.Skip(1).Zip(mapType.domain, (at, mtD) => at.isEquivalent(mtD.substitute(substitution))).All(x => x));
string indexString = makeIndexString(TypeTuple.make(typeArguments), TypeTuple.make(argumentTypes));
BasicMapRead result = null;
bool foundInstance = instances.TryGetValue(indexString, out result);
if (result != null)
{
if (!ReferenceEquals(resultType, result.resultType))
{
foundInstance = false;
}
else
if (argumentTypes.Zip(result.argumentTypes, (x, y) => x.isEquivalent(y)).Any(x => !x))
{
foundInstance = false;
}
}
if (!foundInstance)
{
var indexTypes = argumentTypes.Skip(1);
result = new BasicMapRead(mapType, typeArguments, indexTypes, resultType);
instances[indexString] = result;
}
return(result);
}
private void addConditionalMapEqualityAxiom(Expression[] i, Expression mu, Expression m,
ITypeTuple typeArguments)
{
Debug.Assert(mu.type.ToStringN() == m.type.ToStringN());
string mlIndex = TypeInstanceCollector.makeString(typeArguments);
Debug.Assert(tic.functionInstanceMap["MapRead"].ContainsKey(mlIndex));
Debug.Assert(m.type is MapType);
var mt = m.type as MapType;
TypeInstanceCollector.GFunctionInstance[] tpis = (from tpi in tic.functionInstanceMap["MapRead"].Values
where
tpi.function.typeArguments.First().ToStringN() ==
mt.ToStringN()
select tpi).ToArray();
Debug.Assert(
(from tpi in tpis select TypeInstanceCollector.makeString(tpi.function.typeArguments)).Contains(
TypeInstanceCollector.makeString(typeArguments)));
foreach (var tpi in tpis)
{
var ta = tpi.function.typeArguments;
Debug.Assert(ta.Count() == mt.typeParameters.Count() + 1);
Debug.Assert(ta.First().ToStringN() == mt.ToStringN());
var mta = ta.Skip(1).ToArray();
var ts = new TypeParameterInstantiation(mt.typeParameters, mta);
var at = (from a in mt.domain select a.substitute(ts)).ToArray();
var rt = mt.range.substitute(ts);
var bvs = (from a in at select procedure.makeFreshBoundVariable(a)).ToArray();
var bves =
(from bv in bvs select new BasicBoundVariableExpression(bv)).ToArray();
if (TypeInstanceCollector.makeString(ta) == TypeInstanceCollector.makeString(typeArguments))
{
addAxiom(
sentence(implication(inEquality(bves, i), equality(ml(m, bves, mta, rt), ml(mu, bves, mta, rt)))));
}
else
{
addAxiom(sentence(equality(ml(m, bves, mta, rt), ml(mu, bves, mta, rt))));
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
public IType substitute(TypeParameterInstantiation instantiation)
{
bool clone = false;
var newArguments = new IType[arguments.Count()];
for (int i = 0; i < arguments.Count(); i++)
{
newArguments[i] = arguments[i].substitute(instantiation);
Debug.Assert(newArguments[i] != null);
if (newArguments[i] != arguments[i])
{
clone = true;
}
}
if (clone)
{
return(new TypeConstructorInstance(typeConstructor, newArguments));
}
return(this);
}
private BasicMapRead(MapType mapType, IEnumerable <IType> mapTypeArguments, IEnumerable <IType> indexTypes, IType resultType)
{
Debug.Assert(mapType != null);
Debug.Assert(indexTypes != null);
Debug.Assert(resultType != null);
Debug.Assert(mapType.domain.Count() == indexTypes.Count());
Debug.Assert(mapTypeArguments != null);
Debug.Assert(mapType.typeParameters.Length == mapTypeArguments.Count());
var substitution = new TypeParameterInstantiation(mapType.typeParameters, mapTypeArguments);
Debug.Assert(resultType.ToStringN() == mapType.range.substitute(substitution).ToStringN());
Debug.Assert(mapType.domain.Zip(indexTypes, (x, y) => x.substitute(substitution).isEquivalent(y)).All(x => x));
/* for (int i = 0; i < indexTypes.Count(); i++)
* Debug.Assert(indexTypes[i].ToStringExpanded() ==
* mapType.domain[i].substitute(substitution).ToStringExpanded());
*/
this.mapType = mapType;
mapIndexTypes = TypeTuple.make(indexTypes);
this.resultType = resultType;
this.mapTypeArguments = TypeTuple.make(mapTypeArguments);
}
public bool isEquivalent(IType other)
{
var omt = other as MapType;
if (omt == null)
{
return(false);
}
if (omt.typeParameters.Count() != typeParameters.Count())
{
return(false);
}
if (omt.domain.Count() != domain.Count())
{
return(false);
}
var ttv = canonicalParameterArray();
var otherSub = new TypeParameterInstantiation(omt.typeParameters, ttv);
var thisSub = new TypeParameterInstantiation(typeParameters, ttv);
// var omtUnified = omt.substitute(new TypeParameterInstantiation(omt.mapTypeArguments, ttv)) as MapType;
// var thisUnified = substitute(new TypeParameterInstantiation(mapTypeArguments, ttv)) as MapType;
for (int i = 0; i < domain.Count(); i++)
{
if (!domain[i].substitute(thisSub).isEquivalent(omt.domain[i].substitute(otherSub)))
{
return(false);
}
}
if (!range.substitute(thisSub).isEquivalent(omt.range.substitute(otherSub)))
{
return(false);
}
return(true);
}
public override Function substitute(TypeParameterInstantiation s)
{
return(this);
}
public ExpressionSubstitution()
{
typeSubstitution = new TypeParameterInstantiation();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
public IType substitute(TypeParameterInstantiation instantiation)
{
return(substituteMap(instantiation));
}
public abstract Function substitute(TypeParameterInstantiation s);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private List <List <IType> > getTypesToInstantiate(Expression e)
{
List <TypeVariable> ftvl = e.freeTypeVariables.ToList();
var gtl = new List <IType>();
foreach (var t in qtc.types)
{
if (t.Value.type.freeTypeVariables.Count == 0)
{
gtl.Add(t.Value.type);
}
}
var indices = new int[ftvl.Count];
for (int i = 0; i < ftvl.Count; i++)
{
indices[i] = 0;
}
var result = new List <List <IType> >();
HashSet <IType> ngts = getNonGroundTypes(e);
IEnumerable <string> programGroundTypeNames = from p in qtc.types where p.Value.type.isGround select p.Key;
/* {
* Console.Write("Program Types = {");
* foreach (var t in programGroundTypeNames)
* Console.Write(t + " ");
* Console.WriteLine("}");
* }
*/
while (true)
{
var l = new List <IType>();
for (int i = 0; i < indices.Length; i++)
{
l.Add(gtl[indices[i]]);
}
{
var tpi = new TypeParameterInstantiation(ftvl.ToArray(), l.ToArray());
/* {
* Console.Write("{");
* foreach (var ngt in ngts)
* Console.Write(ngt.substitute(tpi).ToStringExpanded() + "|");
* Console.WriteLine("}");
* }
*/
foreach (var ngt in ngts)
{
Debug.Assert(ngt.substitute(tpi).isGround);
if (!programGroundTypeNames.Contains(ngt.substitute(tpi).ToStringN()))
{
goto skipAdd;
}
}
// Console.WriteLine("Accepted");
result.Add(l);
skipAdd:
;
}
Debug.Assert(indices.Length > 0);
int j = indices.Length - 1;
while (true)
{
Debug.Assert(indices[j] < gtl.Count);
if (indices[j] == gtl.Count - 1)
{
if (j == 0)
{
goto endLoop;
}
else
{
indices[j] = 0;
j--;
}
}
else
{
indices[j]++;
break;
}
}
}
endLoop:
return(result);
}
public IType substitute(TypeParameterInstantiation instantiation)
{
return(this);
}