protected override bool Step(
GraphStructuredProgram <TNode> targetProgram,
ResolvedMethod <TNode> targetMethod,
TNode source,
Statement statement,
TNode target,
Func <TNode> nodeCreator)
{
if (statement is AssignmentStatement assignment)
{
var sourceEntity = ReferenceResolver.Resolve(targetProgram, targetMethod, assignment.Source);
var targetEntity = ReferenceResolver.Resolve(targetProgram, targetMethod, assignment.Target);
var targetSecondaryEntity = targetEntity as SecondaryEntity;
Trace.Assert(targetSecondaryEntity != null);
var referencedByThis =
assignment.Target is ClassFieldReference classFieldReference &&
classFieldReference.Owner is ClassReference classReference &&
classReference.ThisClassReference;
var newStatement = new ResolvedAssignmentStatement(
assignment.Location, sourceEntity, targetSecondaryEntity, referencedByThis);
targetProgram.AddEdge(new OperationEdge <TNode>(source, newStatement, target));
return(false);
}
return(true);
}
public async Task <IEnumerable <ThreadViewModel> > GetPagedItemsAsync(int pageIndex, int pageSize, CancellationToken cancellationToken = default)
{
int totalReply = _post.Hr + _post.Replys.Count;
if (pageIndex * pageSize > totalReply)
{
return(Enumerable.Empty <ThreadViewModel>());
}
var pocos = await _threadController.GetThreadsAsync(_post.No, pageIndex + 1).ConfigureAwait(false);
if (pageIndex == 0)
{
var SelfAsJson = (Thread)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(_post), typeof(Thread));
pocos.Insert(0, SelfAsJson);
}
var threads = pocos.Select(i => new ThreadViewModel(i, _post.Id)).ToList();
foreach (var t in threads)
{
t.AstNodeTask = AstHelper.LoadHtmlAsync(t.Content);
}
var result = await Task.WhenAll(threads.Select(i => i.AstNodeTask));
foreach (var item in result)
{
resolver.Resolve(item, new ResolveContext()
{
Controller = new ReplyController(_config)
});
}
return(threads);
}
protected override bool Step(
GraphStructuredProgram <TNode> targetProgram,
ResolvedMethod <TNode> owningMethod,
TNode source,
Statement statement,
TNode target,
Func <TNode> nodeCreator)
{
SecondaryEntity CreateNewVariable()
{
var nextId = owningMethod.Variables.Keys.Max() + 1;
var variable = new ResolvedLocalVariable(nextId);
owningMethod.AddLocalVariable(variable);
return(variable);
}
if (statement is InvocationStatement invocation)
{
var passedParameters =
invocation.PassedParameters.GroupBy(
pair => ReferenceResolver.Resolve(targetProgram, owningMethod, pair.Value),
pair => pair.Key)
.ToDictionary(
pair =>
{
Trace.Assert(pair.Key != null);
return(pair.Key);
},
pair =>
{
var targets = pair.ToList();
return(targets.Count == 1 ?
targets[0] :
new ParameterIndicesSet(
targets.Select(targetIndex => targetIndex.Value)));
});
var returnedValues =
invocation.ReturnedValues.ToDictionary(
pair =>
{
Trace.Assert(pair.Key != null);
return(pair.Key);
},
pair => (SecondaryEntity)ReferenceResolver.Resolve(targetProgram, owningMethod, pair.Value));
var normalizedPassedParameters = AddIntermediateEdgesIfNeeded(
targetProgram, passedParameters, source, nodeCreator, CreateNewVariable, out var newSource);
ResolvedInvocationStatement <TNode> resolvedInvocationStatement = null;
if (invocation.InvocationTarget is ClassMethodTarget classMethodTarget)
{
var targetMethodId = targetProgram.GetOrCreateMethodId(classMethodTarget.TargetMethod);
var resolvedOwner = ReferenceResolver.Resolve(
targetProgram, owningMethod, classMethodTarget.TargetClass);
resolvedInvocationStatement =
new ResolvedInvocationStatement <TNode>(
invocation, normalizedPassedParameters, returnedValues, resolvedOwner, targetMethodId);
}
if (invocation.InvocationTarget is LocalVariableTarget localVariableTarget)
{
var resolvedOwner = ReferenceResolver.Resolve(
targetProgram, owningMethod, new LocalVariableReference(localVariableTarget.Index));
resolvedInvocationStatement =
new ResolvedInvocationStatement <TNode>(
invocation, normalizedPassedParameters, returnedValues, resolvedOwner, targetProgram.GetOrCreateMethodId("Invoke"));
}
if (invocation.InvocationTarget is ClassFieldTarget classFieldTarget)
{
var resolvedOwner = ReferenceResolver.Resolve(
targetProgram, owningMethod, new ClassFieldReference(classFieldTarget.TargetClass, classFieldTarget.TargetField));
resolvedInvocationStatement =
new ResolvedInvocationStatement <TNode>(
invocation, normalizedPassedParameters, returnedValues, resolvedOwner, targetProgram.GetOrCreateMethodId("Invoke"));
}
if (invocation.InvocationTarget is ClassPropertyTarget classPropertyTarget)
{
var resolvedOwner = ReferenceResolver.Resolve(
targetProgram, owningMethod, new ClassPropertyReference(classPropertyTarget.TargetClass, classPropertyTarget.TargetProperty));
resolvedInvocationStatement =
new ResolvedInvocationStatement <TNode>(
invocation, normalizedPassedParameters, returnedValues, resolvedOwner, targetProgram.GetOrCreateMethodId("Invoke"));
}
if (invocation.InvocationTarget is LocalFunctionTarget localFunctionTarget)
{
var resolvedOwner = owningMethod;
var targetMethodId = targetProgram.GetOrCreateMethodId(localFunctionTarget.TargetFunction.Value);
resolvedInvocationStatement =
new ResolvedInvocationStatement <TNode>(
invocation, normalizedPassedParameters, returnedValues, resolvedOwner, targetMethodId);
}
Trace.Assert(resolvedInvocationStatement != null);
var operation = new Operation <TNode>(resolvedInvocationStatement, target);
targetProgram.AddOperation(newSource, operation);
return(false);
}
return(true);
}
