public virtual TypeswitchCaseList VisitTypeswitchCaseList(TypeswitchCaseList typeswitchCases, TypeswitchCaseList changes, TypeswitchCaseList deletions, TypeswitchCaseList insertions){
if (typeswitchCases == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return typeswitchCases;
}
public virtual Differences VisitTypeswitchCaseList(TypeswitchCaseList list1, TypeswitchCaseList list2,
out TypeswitchCaseList changes, out TypeswitchCaseList deletions, out TypeswitchCaseList insertions){
changes = list1 == null ? null : list1.Clone();
deletions = list1 == null ? null : list1.Clone();
insertions = list1 == null ? new TypeswitchCaseList() : list1.Clone();
//^ assert insertions != null;
Differences differences = new Differences();
for (int j = 0, n = list2 == null ? 0 : list2.Count; j < n; j++){
//^ assert list2 != null;
TypeswitchCase nd2 = list2[j];
if (nd2 == null) continue;
insertions.Add(null);
}
TrivialHashtable savedDifferencesMapFor = this.differencesMapFor;
this.differencesMapFor = null;
TrivialHashtable matchedNodes = new TrivialHashtable();
for (int i = 0, k = 0, n = list1 == null ? 0 : list1.Count; i < n; i++){
//^ assert list1 != null && changes != null && deletions != null;
TypeswitchCase nd1 = list1[i];
if (nd1 == null) continue;
Differences diff;
int j;
TypeswitchCase nd2 = this.GetClosestMatch(nd1, list1, list2, i, ref k, matchedNodes, out diff, out j);
if (nd2 == null || diff == null){Debug.Assert(nd2 == null && diff == null); continue;}
matchedNodes[nd1.UniqueKey] = nd1;
matchedNodes[nd2.UniqueKey] = nd2;
changes[i] = diff.Changes as TypeswitchCase;
deletions[i] = diff.Deletions as TypeswitchCase;
insertions[i] = diff.Insertions as TypeswitchCase;
insertions[n+j] = nd1; //Records the position of nd2 in list2 in case the change involved a permutation
Debug.Assert(diff.Changes == changes[i] && diff.Deletions == deletions[i] && diff.Insertions == insertions[i]);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
}
//Find deletions
for (int i = 0, n = list1 == null ? 0 : list1.Count; i < n; i++){
//^ assert list1 != null && changes != null && deletions != null;
TypeswitchCase nd1 = list1[i];
if (nd1 == null) continue;
if (matchedNodes[nd1.UniqueKey] != null) continue;
changes[i] = null;
deletions[i] = nd1;
insertions[i] = null;
differences.NumberOfDifferences += 1;
}
//Find insertions
for (int j = 0, n = list1 == null ? 0 : list1.Count, m = list2 == null ? 0 : list2.Count; j < m; j++){
//^ assert list2 != null;
TypeswitchCase nd2 = list2[j];
if (nd2 == null) continue;
if (matchedNodes[nd2.UniqueKey] != null) continue;
insertions[n+j] = nd2; //Records nd2 as an insertion into list1, along with its position in list2
differences.NumberOfDifferences += 1; //REVIEW: put the size of the tree here?
}
if (differences.NumberOfDifferences == 0){
changes = null;
deletions = null;
insertions = null;
}
this.differencesMapFor = savedDifferencesMapFor;
return differences;
}
public virtual TypeswitchCase GetClosestMatch(TypeswitchCase/*!*/ nd1, TypeswitchCaseList/*!*/ list1, TypeswitchCaseList list2, int list1pos, ref int list2start,
TrivialHashtable/*!*/ matchedNodes, out Differences closestDifferences, out int list2pos) {
closestDifferences = null; list2pos = -1;
if (list2 == null) return null;
if (nd1 == null || list1 == null || matchedNodes == null || list1pos < 0 || list1pos >= list1.Count || list2start < 0 || list2start >= list2.Count) {
Debug.Assert(false); return null;
}
TypeswitchCase closest = null;
Differences winnerSoFar = null;
for (int j = list2start, m = list2.Count; j < m; j++){
TypeswitchCase nd2 = list2[j];
if (list2start == j) list2start++;
if (nd2 == null) continue;
if (matchedNodes[nd2.UniqueKey] != null) continue;
Differences diff = this.GetDifferences(nd1, nd2);
if (diff == null){Debug.Assert(false); continue;}
if (diff.Similarity <= 0.5){
//Not a good enough match
if (list2start == j+1) list2start--; //The next call to GetClosestMatch will start looking at list2start, so this node will be considered then
continue; //ignore it for the rest of this call
}
if (winnerSoFar != null && winnerSoFar.Similarity >= diff.Similarity) continue;
winnerSoFar = closestDifferences = diff;
closest = nd2;
list2pos = j;
if (diff.NumberOfDifferences == 0) return closest; //Perfect match, no need to look for other matches
}
if (closest != null){
//^ assert winnerSoFar != null;
//closest is closer to nd1 than any other node in list2, but this is no good if some other node in list1 has a better claim on closest
for (int i = list1pos+1, n = list1.Count; i < n; i++){
TypeswitchCase nd1alt = list1[i];
if (nd1alt == null) continue;
if (matchedNodes[nd1alt.UniqueKey] != null) continue;
Differences diff = this.GetDifferences(nd1alt, closest);
if (diff == null){Debug.Assert(false); continue;}
if (diff.Similarity <= winnerSoFar.Similarity) continue;
//nd1alt has a better claim on closest. See if it wants closest.
Differences diff2;
int j, k = list2start;
TypeswitchCase nd2alt = this.GetClosestMatch(nd1alt, list1, list2, i, ref k, matchedNodes, out diff2, out j);
if (nd2alt != closest){
Debug.Assert(nd2alt != null && diff2 != null && diff2.Similarity >= diff.Similarity);
continue; //nd1alt prefers nd2alt to closest, so closest is still available
}
//nd1alt wants closest, take it out of the running
matchedNodes[closest.UniqueKey] = nd1alt;
//Now that closest is out of the running, try again
k = list2start;
TypeswitchCase newClosest = this.GetClosestMatch(nd1, list1, list2, i, ref k, matchedNodes, out winnerSoFar, out list2pos);
//put closest back in the running so that the next call to this routine will pick it up
matchedNodes[closest.UniqueKey] = closest;
closest = newClosest;
break;
}
}
closestDifferences = winnerSoFar;
return closest;
}
public virtual void VisitTypeswitchCaseList(TypeswitchCaseList oldCases, TypeswitchCaseList newCases, TypeUnion tUnion) {
if (oldCases == null || newCases == null || tUnion == null) { Debug.Assert(false); return; }
TypeNodeList types = tUnion.Types;
if (types == null) return;
bool complainedAboutDefault = false;
for (int i = 0, n = oldCases.Count; i < n; i++) {
TypeswitchCase tcase = this.VisitTypeswitchCase(oldCases[i]);
if (tcase == null) continue;
TypeNode t = tcase.LabelType;
if (t == null) {
if (tcase.LabelTypeExpression == null && !complainedAboutDefault) {
complainedAboutDefault = true;
this.HandleError(tcase, Error.DefaultNotAllowedInTypeswitch);
}
continue;
}
int j = types.SearchFor(t);
if (j < 0) {
//TODO: look for a single field tuple with the same type as t and arrange for coercion
this.HandleError(tcase.LabelTypeExpression, Error.TypeCaseNotFound, this.GetTypeName(t), this.GetTypeName(tUnion));
continue;
}
if (newCases[j] != null) continue; //TODO: give an error
newCases[j] = tcase;
}
}
public virtual TypeswitchCaseList VisitTypeswitchCaseList(TypeswitchCaseList typeswitchCases){
if (typeswitchCases == null) return null;
for (int i = 0, n = typeswitchCases.Count; i < n; i++)
typeswitchCases[i] = this.VisitTypeswitchCase(typeswitchCases[i]);
return typeswitchCases;
}
public override TypeswitchCaseList VisitTypeswitchCaseList(TypeswitchCaseList typeswitchCases)
{
throw new ApplicationException("unimplemented");
}
public virtual void VisitTypeswitchCaseList(TypeswitchCaseList typeswitchCases)
{
if (typeswitchCases == null) return;
for (int i = 0, n = typeswitchCases.Count; i < n; i++)
this.VisitTypeswitchCase(typeswitchCases[i]);
}
public virtual TypeswitchCaseList VisitTypeswitchCaseList(TypeswitchCaseList typeswitchCases1, TypeswitchCaseList typeswitchCases2)
{
if (typeswitchCases1 == null) return null;
for (int i = 0, n = typeswitchCases1.Count, m = typeswitchCases2 == null ? 0 : typeswitchCases2.Count; i < n; i++)
{
//^ assert typeswitchCases2 != null;
if (i >= m)
typeswitchCases1[i] = this.VisitTypeswitchCase(typeswitchCases1[i], null);
else
typeswitchCases1[i] = this.VisitTypeswitchCase(typeswitchCases1[i], typeswitchCases2[i]);
}
return typeswitchCases1;
}
public override TypeswitchCaseList VisitTypeswitchCaseList(TypeswitchCaseList typeswitchCases)
{
if (typeswitchCases == null) return null;
return base.VisitTypeswitchCaseList(typeswitchCases.Clone());
}
public virtual void VisitTypeswitchCaseList(TypeswitchCaseList oldCases, BlockList targets, StatementList statements, Block nextStatement, Local temp){
for (int i = 0, n = oldCases.Count; i < n; i++){
TypeswitchCase tcase = oldCases[i];
StatementList stats = new StatementList(3);
Block b = new Block(stats);
if (tcase != null){
Expression expr = null;
if (tcase.LabelType.IsValueType)
expr = new AddressDereference(new BinaryExpression(temp, new Literal(tcase.LabelType, SystemTypes.Type), NodeType.Unbox), tcase.LabelType);
else
expr = new BinaryExpression(temp, new Literal(tcase.LabelType, SystemTypes.Type), NodeType.Castclass);
stats.Add(new AssignmentStatement(this.VisitTargetExpression(tcase.LabelVariable), expr));
stats.Add(this.VisitBlock(tcase.Body));
}
stats.Add(new Branch(null, nextStatement));
statements.Add(b);
targets.Add(b);
}
}
public Typeswitch(Expression expression, TypeswitchCaseList cases)
: base(NodeType.Typeswitch)
{
this.Cases = cases;
this.Expression = expression;
}
public override TypeswitchCaseList VisitTypeswitchCaseList(TypeswitchCaseList typeswitchCases)
{
throw new ApplicationException("unimplemented");
}
public override TypeswitchCaseList VisitTypeswitchCaseList(TypeswitchCaseList typeswitchCases)
{
throw new NotImplementedException("Node type not yet supported");
}
public EventingVisitor(Action<TypeswitchCaseList> visitTypeswitchCaseList) { VisitedTypeswitchCaseList += visitTypeswitchCaseList; } public event Action<TypeswitchCaseList> VisitedTypeswitchCaseList; public override TypeswitchCaseList VisitTypeswitchCaseList(TypeswitchCaseList typeswitchCases) { if (VisitedTypeswitchCaseList != null) VisitedTypeswitchCaseList(typeswitchCases); return base.VisitTypeswitchCaseList(typeswitchCases); }
