public ResolvedMethod <TNode> FindMethodById(ResolvedClassId classId, ResolvedMethodId methodId)
{
if (classId == null)
{
return(null);
}
myClasses.TryGetValue(classId, out var clazz);
return(clazz?.FindMethodInFullHierarchy(methodId));
}
public ResolvedInvocationStatement(
ResolvedInvocationStatement <TNode> source,
Entity resolvedEntity,
ResolvedMethodId resolvedMethodId,
Dictionary <SecondaryEntity, ParameterIndex> passedParameters,
Dictionary <ParameterIndex, SecondaryEntity> returnedValues)
: base(source.Location)
{
TargetEntity = resolvedEntity;
TargetMethodId = resolvedMethodId;
PassedParameters = passedParameters;
ReturnedValues = returnedValues;
IsConstructor = source.IsConstructor;
}
public void RemoveMethod(IMethodHolder <TNode> owner, ResolvedMethodId methodId)
{
var method = owner.FindLocalMethod(methodId);
var toRemove = method.Methods.Keys.ToList();
foreach (var localFunction in toRemove)
{
RemoveMethod(method, localFunction);
}
var toDelete = method.GetOwnedNodes();
foreach (var node in toDelete)
{
RemoveVertex(node);
myOnNodeRemovedHandler(node);
}
var exists = owner.RemoveMethod(methodId);
Trace.Assert(exists);
}
public ResolvedMethod <TNode> GetOrCreateMethod(IMethodHolder <TNode> owner, string name)
{
var rawMethodId = Methods.FindOrAdd(name);
var methodId = new ResolvedMethodId(rawMethodId);
var method = owner.FindLocalMethod(methodId);
if (method == null)
{
var start = myNodesProvider();
var end = myNodesProvider();
AddVertex(start);
AddVertex(end);
method = new ResolvedMethod <TNode>(methodId, start, end);
owner.AddMethod(methodId, method);
return(method);
}
return(method);
}
private IEnumerable <IInvokable <Node> > CollectInstances(SecondaryEntity reference, ResolvedMethodId targetId)
{
return(reference.CollectedPrimaries.Select(
type =>
{
if (type is ResolvedClassId classId)
{
var target = myProcessingProgram
.FindClassById(classId)
.FindMethodInFullHierarchy(targetId);
return (IInvokable <Node>)target;
}
if (type is IInvokable <Node> invocable)
{
return invocable;
}
return null;
}).Where(target => target != null));
}
protected IEnumerable <IInvokable <Node> > CollectPossibleTargets(Entity reference, ResolvedMethodId targetId)
{
if (reference is ResolvedClassId staticClass)
{
IEnumerable <IInvokable <Node> > Iterator(ResolvedMethod <Node> method)
{
if (method != null)
{
yield return(method);
}
}
var resolvedMethod = Program.FindClassById(staticClass).FindMethodInFullHierarchy(targetId);
return(Iterator(resolvedMethod));
}
if (reference is SecondaryEntity secondary)
{
return(secondary.CollectedPrimaries.Select(
type =>
{
if (type is ResolvedClassId classId)
{
var target = Program
.FindClassById(classId)
.FindMethodInFullHierarchy(targetId);
return (IInvokable <Node>)target;
}
if (type is IInvokable <Node> invokable)
{
return invokable;
}
return null;
}).Where(target => target != null));
}
return(Enumerable.Empty <IInvokable <Node> >());
}
public ResolvedObjectMethodReference(SecondaryEntity owningObject, ResolvedMethodId methodId)
{
OwningObject = owningObject;
MethodId = methodId;
}
