internal override bool ResolveTypes(SymbolTable table, List <Flag> flags, CancellationToken cancel)
{
var first = definitions.First <AST <MapDecl> >();
var result = BuildFldAttrs(flags, first.Node.Dom, true) &
BuildFldAttrs(flags, first.Node.Cod, false);
int i;
AppFreeCanUnn[] cdefs;
foreach (var def in definitions)
{
i = 0;
cdefs = new AppFreeCanUnn[Arity];
foreach (var fld in def.Node.Dom)
{
cdefs[i] = new AppFreeCanUnn(table, Factory.Instance.ToAST(fld.Type));
result = cdefs[i].ResolveTypes(flags, cancel) & result;
++i;
}
foreach (var fld in def.Node.Cod)
{
cdefs[i] = new AppFreeCanUnn(table, Factory.Instance.ToAST(fld.Type));
result = cdefs[i].ResolveTypes(flags, cancel) & result;
++i;
}
def.Node.CompilerData = cdefs;
}
return(result);
}
internal override bool ResolveTypes(SymbolTable table, List <Flag> flags, CancellationToken cancel)
{
var result = true;
foreach (var def in definitions)
{
var cdef = new AppFreeCanUnn(table, Factory.Instance.ToAST(def.Node.Body));
result = cdef.ResolveTypes(flags, cancel) & result;
def.Node.CompilerData = cdef;
}
return(result);
}
/// <summary>
/// Tests if unn contains synactically the same elements as this union.
/// </summary>
internal bool IsEquivalent(AppFreeCanUnn unn)
{
Contract.Requires(unn != null);
if (unn == this)
{
return(true);
}
else if (elements.Count != unn.elements.Count ||
intervals.Count != unn.intervals.Count)
{
return(false);
}
using (var it1 = elements.GetEnumerator())
{
using (var it2 = unn.elements.GetEnumerator())
{
while (it1.MoveNext() & it2.MoveNext())
{
if (it1.Current != it2.Current)
{
return(false);
}
}
}
}
using (var it1 = intervals.CanonicalForm.GetEnumerator())
{
using (var it2 = unn.intervals.CanonicalForm.GetEnumerator())
{
while (it1.MoveNext() & it2.MoveNext())
{
if (it1.Current.Key != it2.Current.Key ||
it1.Current.Value != it2.Current.Value)
{
return(false);
}
}
}
}
return(true);
}
internal override bool ResolveTypes(SymbolTable table, List <Flag> flags, CancellationToken cancel)
{
int i;
var result = BuildFldAttrs(flags);
AppFreeCanUnn[] cdefs;
foreach (var def in definitions)
{
i = 0;
cdefs = new AppFreeCanUnn[Arity];
foreach (var fld in def.Node.Fields)
{
cdefs[i] = new AppFreeCanUnn(table, Factory.Instance.ToAST(fld.Type));
result = cdefs[i].ResolveTypes(flags, cancel) & result;
++i;
}
def.Node.CompilerData = cdefs;
}
return(result);
}
internal override bool Canonize(List <Flag> flags, CancellationToken cancel)
{
AppFreeCanUnn cdef = null, cdefp = null;
var result = true;
foreach (var def in definitions)
{
cdef = (AppFreeCanUnn)def.Node.CompilerData;
if (cdefp == null)
{
cdefp = cdef;
}
result = cdef.Canonize(FullName, flags, cancel, this) & result;
if (!cdefp.IsEquivalent(cdef))
{
var flag = new Flag(
SeverityKind.Error,
cdef.TypeExpr.Node,
Constants.DuplicateDefs.ToString(
string.Format("type {0}", FullName),
cdef.TypeExpr.GetCodeLocationString(Namespace.SymbolTable.Env.Parameters),
cdefp.TypeExpr.GetCodeLocationString(Namespace.SymbolTable.Env.Parameters)),
Constants.DuplicateDefs.Code);
flags.Add(flag);
result = false;
}
}
if (result)
{
Contract.Assert(cdef != null);
SetCanonicalForm(new AppFreeCanUnn[] { cdef });
}
return(result);
}
public SubtermMatcher(TermIndex index, bool onlyNewKinds, Term[] pattern)
{
Contract.Requires(pattern != null && pattern.Length > 0);
//// Appears that Requires is triggering bug in Code Contracts 1.9.10714.2
Contract.Assert(index != null);
this.pattern = pattern;
IsMatchOnlyNewKinds = onlyNewKinds;
matchingUnions = new AppFreeCanUnn[pattern.Length];
bool wasAdded;
Term type, intr;
Term levelTypes = null;
IsSatisfiable = true;
IsTriggerable = false;
Stack <Term> pending = new Stack <Term>();
Set <Term> pendingOrVisited = new Set <Term>(Term.Compare);
for (int i = pattern.Length - 1; i >= 0; --i)
{
if (!IsSatisfiable)
{
return;
}
if (i == pattern.Length - 1)
{
intr = pattern[pattern.Length - 1];
}
else if (!index.MkIntersection(pattern[i], levelTypes, out intr))
{
IsSatisfiable = false;
return;
}
levelTypes = null;
IsSatisfiable = false;
pendingOrVisited.Clear();
foreach (var t in intr.Enumerate(x => x.Symbol == index.TypeUnionSymbol ? x.Args : null))
{
if (t.Symbol == index.TypeUnionSymbol)
{
continue;
}
else if (IsPermitted(index, onlyNewKinds, t))
{
IsSatisfiable = true;
GetMatchingSet(i, t).Add(CanMatch);
pending.Push(t);
pendingOrVisited.Add(t);
levelTypes = levelTypes == null ? t : index.MkApply(index.TypeUnionSymbol, new Term[] { t, levelTypes }, out wasAdded);
if (i == 0 && (t.Symbol.Kind == SymbolKind.UserSortSymb || t.Symbol.IsDerivedConstant))
{
IsTriggerable = true;
}
}
}
if (!IsSatisfiable)
{
return;
}
else
{
matchingUnions[i] = new AppFreeCanUnn(levelTypes);
}
while (pending.Count > 0)
{
type = pending.Pop();
foreach (var tup in index.GetTypeUses(type))
{
if (tup.Item1.Kind == SymbolKind.ConSymb)
{
type = index.MkApply(((ConSymb)tup.Item1).SortSymbol, TermIndex.EmptyArgs, out wasAdded);
}
else if (tup.Item1.Kind == SymbolKind.MapSymb)
{
type = index.MkApply(((MapSymb)tup.Item1).SortSymbol, TermIndex.EmptyArgs, out wasAdded);
}
else
{
throw new NotImplementedException();
}
if (IsPermitted(index, onlyNewKinds, type))
{
GetMatchingSet(i, type).Add(tup.Item2);
if (!pendingOrVisited.Contains(type))
{
pending.Push(type);
pendingOrVisited.Add(type);
levelTypes = levelTypes == null ? type : index.MkApply(index.TypeUnionSymbol, new Term[] { type, levelTypes }, out wasAdded);
if (i == 0 && (type.Symbol.Kind == SymbolKind.UserSortSymb || type.Symbol.IsDerivedConstant))
{
IsTriggerable = true;
}
}
}
}
}
}
if (IsTriggerable)
{
var level0 = matcher[0];
levelTypes = null;
foreach (var kv in level0)
{
if (kv.Key.Symbol.Kind == SymbolKind.UserSortSymb || kv.Key.Symbol.IsDerivedConstant)
{
levelTypes = levelTypes == null ? kv.Key : index.MkApply(index.TypeUnionSymbol, new Term[] { kv.Key, levelTypes }, out wasAdded);
}
}
Trigger = levelTypes;
}
}
