internal GraphAnnotationData(PropGraphNodeDescriptor m)
{
this.DeletedElems = new HashSet<TypeDescriptor>();
this.Delegates = new HashSet<MethodDescriptor>();
this.Node = m;
this.HasRetValue = false;
}
internal async Task<bool> IsAssignableAsync(TypeDescriptor t1, PropGraphNodeDescriptor analysisNode)
{
// Contract.Assert(this.codeProvider!=null);
if (codeProvider == null)
{
return true;
}
var res = true;
// Ugly
TypeDescriptor type1 = t1;
var type2 = analysisNode.Type;
if (!(await this.codeProvider.IsSubtypeAsync(type1, type2)))
{
if (!type2.IsDelegate)
{
if (!IsCallNode(analysisNode) && !IsDelegateCallNode(analysisNode))
{
return false;
}
}
}
return res;
}
internal async Task<ISet<TypeDescriptor>> GetPotentialTypesAsync(PropGraphNodeDescriptor n, PropagationGraph propGraph, ICodeProvider codeProvider)
{
var result = new HashSet<TypeDescriptor>();
foreach (var typeDescriptor in propGraph.GetTypes(n))
{
// TO-DO fix by adding a where T: AnalysisType
if (typeDescriptor.IsConcreteType)
{
result.Add(typeDescriptor);
}
else
{
Contract.Assert(this.InstatiatedTypes != null);
foreach(var candidateType in this.InstatiatedTypes)
{
var isSubtype = await codeProvider.IsSubtypeAsync(candidateType, typeDescriptor);
if(isSubtype)
{
result.Add(candidateType);
}
}
}
}
return result;
}
internal async Task<bool> DiffPropAsync(IEnumerable<TypeDescriptor> src, PropGraphNodeDescriptor n, PropagationKind propKind)
{
if (propKind == PropagationKind.REMOVE_TYPES || propKind == PropagationKind.REMOVE_ASSIGNMENT)
{
return DiffDelProp(src, n);
}
else
{
return await DiffPropAsync(src, n);
}
}
internal AnalysisInvocationExpession(MethodDescriptor caller, AnalysisCallNode callNode,
PropGraphNodeDescriptor reciever,
IList<PropGraphNodeDescriptor> arguments, VariableNode lhs)
{
Caller = caller;
Arguments = arguments;
LHS = lhs;
Receiver = reciever;
IsStatic = false;
CallNode = callNode;
InstatiatedTypes = new HashSet<TypeDescriptor>();
}
internal ISet<TypeDescriptor> GetPotentialTypes(PropGraphNodeDescriptor n, PropagationGraph propGraph, ICodeProvider codeProvider)
{
var result = new HashSet<TypeDescriptor>();
foreach (var typeDescriptor in propGraph.GetTypes(n))
{
// TO-DO fix by adding a where T: AnalysisType
if (typeDescriptor.IsConcreteType)
{
result.Add(typeDescriptor);
}
else
{
// If it is a declaredTyped it means we were not able to compute a concrete type
// Therefore, we instantiate all compatible types for the set of instantiated types
//result.UnionWith(this.InstatiatedTypes.Where(iType => iType.IsSubtype(typeDescriptor)));
Contract.Assert(this.InstatiatedTypes != null);
// Diego: This requires a Code Provider. Now it will simply fail.
result.UnionWith(this.InstatiatedTypes.Where(candidateTypeDescriptor
=> codeProvider.IsSubtype(candidateTypeDescriptor, typeDescriptor)));
}
}
return result;
}
internal async Task<bool> DiffPropAsync(IEnumerable<TypeDescriptor> src, PropGraphNodeDescriptor n)
{
var ts = GetTypesMS(n);
int c = ts.Count;
foreach(var t in src)
{
if(!ts.Contains(t) )
{
var isAsig = await IsAssignableAsync(t, n);
if(isAsig)
{
ts.Add(t);
}
}
}
//ts.UnionWith(src.Where(t => !ts.Contains(t) && (await IsAssignableAsync(t, n))));
if (ts.Count > c)
{
this.AddToWorkList(n);
return true;
}
return false;
}
internal void RemoveTypes(PropGraphNodeDescriptor n, IEnumerable<TypeDescriptor> ts)
{
var v = AddVertex(n);
v.Value.DeletedElems.UnionWith(ts);
}
internal bool IsAssignable(TypeDescriptor t1, PropGraphNodeDescriptor analysisNode)
{
// Contract.Assert(this.codeProvider!=null);
if(codeProvider==null)
{
return true;
}
var res = true;
// Ugly
TypeDescriptor type1 = t1;
var type2 = analysisNode.Type;
// if (!type1.IsSubtype(type2))
// Diego: This requires a Code Provider. Now it will simply fail.
if (!this.codeProvider.IsSubtype(type1, type2))
{
if (!type2.IsDelegate)
{
if (!IsCallNode(analysisNode) && !IsDelegateCallNode(analysisNode))
{
return false;
}
}
}
//foreach(var t2 in ts.AsSet())
//{
// AnalysisType type2 = (AnalysisType)t2;
// if (!type1.IsSubtype(type2))
// if (!IsCallNode(n) && !IsDelegateCallNode(n))
// return false;
//}
return res;
}
public bool DiffPropDelegates(IEnumerable<MethodDescriptor> src, PropGraphNodeDescriptor analysisNode)
{
var ts = GetDelegates(analysisNode);
int c = ts.Count;
ts.UnionWith(src.Where(t => !ts.Contains(t)));
if (ts.Count > c)
{
this.AddToWorkList(analysisNode);
return true;
}
return false;
}
public void Add(PropGraphNodeDescriptor analysisNode)
{
var v = AddVertex(analysisNode);
}
private GraphNode<GraphNodeAnnotationData> GetVertex(PropGraphNodeDescriptor n)
{
return graph.GetNode(vIndex[n]);
}
internal void Add(PropGraphNodeDescriptor n, IEnumerable<TypeDescriptor> ts)
{
var v = AddVertex(n);
v.Value.Elems.UnionWith(ts);
}
internal void Add(PropGraphNodeDescriptor n, TypeDescriptor t)
{
var v = AddVertex(n);
v.Value.Elems.Add(t);
}
public void ReplaceNode(PropGraphNodeDescriptor nOld, PropGraphNodeDescriptor nNew)
{
long index;
if (vIndex.TryGetValue(nOld, out index))
{
var v = graph.GetNode(index);
v.Value.Node = nNew;
vIndex[nNew] = index;
vIndex.Remove(nOld);
}
}
public void RemoveFromWorkList(PropGraphNodeDescriptor n)
{
workList.Remove(n);
//workList = workList.Remove(n);
}
public bool IsDelegateCallNode(PropGraphNodeDescriptor n)
{
var index = vIndex[n];
var v = graph.GetNode(index);
return v.Value.CallNode != null && v.Value.CallNode is DelegateCallInfo;
}
public AnalysisInvocationExpession GetInvocationInfo(PropGraphNodeDescriptor callNode)
{
Contract.Requires(IsCallNode(callNode) || IsDelegateCallNode(callNode));
long index;
if (vIndex.TryGetValue(callNode, out index))
{
var v = graph.GetNode(index);
//return (AInvocationExp<M, T, N>)v["Call"];
return v.Value.CallNode;
}
return null;
}
public ISet<MethodDescriptor> GetDelegates(PropGraphNodeDescriptor analysisNode)
{
var result = new HashSet<MethodDescriptor>();
long index;
if (vIndex.TryGetValue(analysisNode, out index))
{
var v = graph.GetNode(index);
return v != null ? v.Value.Delegates : result;
}
return result;
}
internal ISet<TypeDescriptor> TypesInEdge(PropGraphNodeDescriptor n1, PropGraphNodeDescriptor n2)
{
long iN1, iN2;
if (vIndex.TryGetValue(n1, out iN1) && vIndex.TryGetValue(n2, out iN2))
{
var e = graph.GetEdge(iN1, iN2);
return e.Value.Types;
}
else
{
return new HashSet<TypeDescriptor>();
}
}
private GraphNode<GraphNodeAnnotationData> AddVertex(PropGraphNodeDescriptor analysisNode)
{
long index;
GraphNode<GraphNodeAnnotationData> node = null;
if (!vIndex.TryGetValue(analysisNode, out index))
{
var data = new GraphNodeAnnotationData(analysisNode);
index = (long)vIndex.Count;
vIndex[analysisNode] = index;
graph.Add(index, data);
}
node = graph.GetNode(index);
return node;
}
//public void AddDelegateCall(DelegateCallExp<M, T, N> call, N callNode)
//{
// var v = AddVertex(callNode, call);
// callNodes.Add(callNode);
//}
internal void AddRet(PropGraphNodeDescriptor rv)
{
var v = AddVertex(rv);
v.Value.HasRetValue = true;
}
bool IsRetNode(PropGraphNodeDescriptor n)
{
var index = vIndex[n];
var v = graph.GetNode(index);
return v.Value.HasRetValue;
}
internal bool DiffDelProp(IEnumerable<TypeDescriptor> src, PropGraphNodeDescriptor n)
{
var delTypes = GetDeletedTypes(n);
if (delTypes.IsSupersetOf(src))
return false;
var ts = GetTypesMS(n);
int c = ts.Count;
var removed = ts.ExceptWith(src);
if (removed.Count() > 0)
{
this.AddToDeletionWorkList(n);
// It should be the
this.RemoveTypes(n, removed);
return true;
}
return false;
}
internal CallInfo(MethodDescriptor caller, AnalysisCallNode callNode, MethodDescriptor callee,
PropGraphNodeDescriptor reciever, IList<PropGraphNodeDescriptor> arguments,
VariableNode lhs, bool isConstructor)
: base(caller, callNode, reciever, arguments, lhs)
{
Caller = caller;
Callee = callee;
Arguments = arguments;
LHS = lhs;
Receiver = reciever;
IsStatic = false;
IsConstructor = isConstructor;
}
internal ISet<TypeDescriptor> GetDeletedTypes(PropGraphNodeDescriptor m)
{
var res = new HashSet<TypeDescriptor>();
long index;
if (vIndex.TryGetValue(m, out index))
{
var v = graph.GetNode(index);
return v != null ? v.Value.DeletedElems : res;
}
return res;
}
internal DelegateCallInfo(MethodDescriptor caller, AnalysisCallNode callNode,
DelegateVariableNode calleeDelegate, PropGraphNodeDescriptor receiver,
IList<PropGraphNodeDescriptor> arguments, VariableNode lhs)
: base(caller, callNode, arguments, lhs)
{
Caller = caller;
CalleeDelegate = calleeDelegate;
Receiver = receiver;
Arguments = arguments;
LHS = lhs;
}
internal Bag<TypeDescriptor> GetTypesMS(PropGraphNodeDescriptor analysisNode)
{
var result = new Bag<TypeDescriptor>();
long index;
if (vIndex.TryGetValue(analysisNode, out index))
{
var v = graph.GetNode(index);
return v != null ? v.Value.Elems : result;
}
return result;
}
internal bool DiffProp(IEnumerable<TypeDescriptor> src, PropGraphNodeDescriptor n)
{
var ts = GetTypesMS(n);
int c = ts.Count;
ts.UnionWith(src.Where(t => !ts.Contains(t) && IsAssignable(t, n)));
if (ts.Count > c)
{
this.AddToWorkList(n);
return true;
}
return false;
}
public void AddToWorkList(PropGraphNodeDescriptor n)
{
workList.Add(n);
//workList = workList.Add(n);
}
