public static Entity Resolve <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Reference reference)
{
if (reference == null)
{
Console.Error.WriteLine("Null reference");
return(null);
}
var type = reference.GetType();
if (!Resolvers.ContainsKey(type))
{
Console.Error.WriteLine($"Cannot find resolver for reference type {type}");
}
var resolved = Resolvers[type].InternalResolve(program, method, reference);
if (resolved == null)
{
Console.Error.WriteLine($"Reference of type {type} has been resolved as null");
}
return(resolved);
}
protected override Entity InternalResolve <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Reference reference)
{
var property = (ClassPropertyReference)reference;
return(Resolve(program, method, new ClassFieldReference(property.Owner, property.Name)));
}
protected override bool Step(
GraphStructuredProgram <TNode> targetProgram,
ResolvedMethod <TNode> targetMethod,
TNode source, Statement statement, TNode target,
Func <TNode> nodeCreator)
{
targetProgram.AddOperation(source, new Operation <TNode>(statement, target));
return(true);
}
protected override Entity InternalResolve <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Reference reference)
{
var real = (ClassReference)reference;
return(program.GetOrCreateClass(real.ClassId).Id);
}
protected override Entity RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Entity entity)
{
var localFunctionReference = (ResolvedLocalFunctionReference <TNode>)entity;
method.Methods.TryGetValue(localFunctionReference.MethodId, out var restored);
localFunctionReference.Method = restored;
return(localFunctionReference);
}
protected override Entity RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Entity entity)
{
var classField = (ResolvedClassField)entity;
var clazz = program.FindClassById(classField.ClassId);
return(clazz.GetOrCreateField(classField.VariableId));
}
protected override Entity RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Entity entity)
{
var classMethodReference = (ResolvedClassMethodReference <TNode>)entity;
classMethodReference.Method =
program.FindMethodById(classMethodReference.OwnerId, classMethodReference.MethodId);
return(classMethodReference);
}
public static Entity Restore <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Entity entity)
{
var exists = RegisteredRestorers.TryGetValue(entity.GetType(), out var restorer);
if (exists)
{
return(restorer.RestoreImplementation(program, method, entity));
}
return(entity);
}
public static InternalStatement Restore <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
InternalStatement statement)
{
var exists = RegisteredRestorers.TryGetValue(statement.InternalType, out var restorer);
if (exists)
{
return(restorer.RestoreImplementation(program, method, statement));
}
return(statement);
}
public static ApiMemberInfo Describe(this ResolvedMethod src)
{
var dst = new ApiMemberInfo();
var msil = ClrDynamic.msil(src.EntryPoint, src.Uri, src.Method);
dst.EntryPoint = src.EntryPoint;
dst.ApiKind = src.Method.KindId();
dst.CliSig = msil.CliSig;
dst.DisplaySig = src.Method.DisplaySig().Format();
dst.Token = msil.Token;
dst.Uri = src.Uri.Format();
dst.MsilCode = msil.Code;
return(dst);
}
private void RestoreLocalFunctionsVariables(ResolvedMethod <TNode> root)
{
foreach (var localFunction in root.Methods.Values)
{
foreach (var localFunctionVariable in localFunction.Variables.Keys.ToList())
{
if (root.Variables.ContainsKey(localFunctionVariable))
{
localFunction.RemoveLocalVariable(localFunctionVariable);
localFunction.AddLocalVariable(root.Variables[localFunctionVariable]);
}
}
RestoreLocalFunctionsVariables(localFunction);
}
}
private static void EnrichFastDemystify(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
{
ResolvedMethod callerMethod = null !;
Type? callerType = null;
{
StackFrame[] frames = new StackTrace().GetFrames();
bool gotToSerilogYet = false;
for (int i = 0; i < frames.Length; i++)
{
MethodBase?tempCallerMethod = frames[i].GetMethod();
if (tempCallerMethod is null)
{
continue;
}
callerMethod = EnhancedStackTrace.GetMethodDisplayString(tempCallerMethod);
callerType = callerMethod.DeclaringType;
if (callerType is null)
{
continue;
}
bool isSerilog = callerType.Namespace?.StartsWith("Serilog") ?? false;
switch (gotToSerilogYet)
{
case false when !isSerilog:
continue;
case false:
gotToSerilogYet = true;
continue;
}
if (isSerilog)
{
continue;
}
//Finally found the right number
//https://youtu.be/Vy7RaQUmOzE?t=203
break;
}
}
//Now do the actual enriching, with nicer names
string callingMethodStr = callerMethod.Name !;
string callingTypeStr = callerType is null ? "<Module>" : StringBuilderPool.BorrowInline(static (sb, callerType) => sb.AppendTypeDisplayName(callerType, false), callerType);
protected override Entity RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Entity entity)
{
var objectMethodReference = (ResolvedObjectMethodReference <TNode>)entity;
var restoredOwner = (SecondaryEntity)Restore(program, method, objectMethodReference.OwningObject);
var restored = new ResolvedObjectMethodReference <TNode>(restoredOwner, objectMethodReference.MethodId)
{
FindClassMethod = program.FindMethodById
};
method.StoreAdditionalVariable(restored);
return(restored);
}
protected override InternalStatement RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
InternalStatement statement)
{
var assignment = (ResolvedAssignmentStatement)statement;
var source = EntitiesRestorer.Restore(program, method, assignment.Source);
Trace.Assert(assignment.Target != null);
var target = assignment.Target == null ? null : EntitiesRestorer.Restore(program, method, assignment.Target);
Trace.Assert(target is SecondaryEntity);
return(new ResolvedAssignmentStatement(
assignment.Location, source, (SecondaryEntity)target, assignment.TargetReferencedByThis));
}
protected override Entity InternalResolve <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> sourceMethod,
Reference reference)
{
var localFunctionReference = (LocalFunctionReference)reference;
var methodId = program.GetOrCreateMethodId(localFunctionReference.MethodId.Value);
var method = sourceMethod.Methods[methodId];
var resolvedReference = new ResolvedLocalFunctionReference <TNode>(methodId)
{
Method = method
};
return(resolvedReference);
}
protected override Entity RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Entity entity)
{
var localVariable = (ResolvedLocalVariable)entity;
var exists = method.Variables.TryGetValue(localVariable.LocalId, out var variable);
//Trace.Assert(exists);
if (!exists)
{
method.AddLocalVariable(localVariable);
variable = localVariable;
}
return(variable);
}
private bool InternalStep(
GraphStructuredProgram <TNode> targetProgram,
ResolvedMethod <TNode> targetMethod,
TNode source,
Statement statement,
TNode target,
Func <TNode> nodeCreator)
{
//TODO: Check steps order correctness
var toContinue =
myComposedWith?.InternalStep(targetProgram, targetMethod, source, statement, target, nodeCreator);
if (toContinue == null || toContinue.Value)
{
return(Step(targetProgram, targetMethod, source, statement, target, nodeCreator));
}
return(false);
}
private Func <int, Node> GetLocalMapper(ResolvedMethod <Node> method)
{
var localToGlobalIndicesMap = new Dictionary <int, Node>();
Node Map(int local)
{
var exists = localToGlobalIndicesMap.TryGetValue(local, out var global);
if (!exists)
{
global = myProgram.CreateNode();
method.AddOwnedNode(global);
localToGlobalIndicesMap.Add(local, global);
}
return(global);
}
return(Map);
}
private static void AppendMethod(this StringBuilder builder, ResolvedMethod method)
{
if (method.IsAsync)
{
builder.Append("async ");
}
if (method.ReturnParameter.Type != null)
{
builder
.AppendParameter(method.ReturnParameter)
.Append(" ");
}
var isSubMethodOrLambda = !string.IsNullOrEmpty(method.SubMethod) || method.IsLambda;
builder
.AppendMethodName(method.Name, method.DeclaringTypeName, isSubMethodOrLambda)
.Append(method.GenericArguments)
.AppendParameters(method.Parameters, method.MethodBase != null);
if (isSubMethodOrLambda)
{
builder
.Append("+")
.Append(method.SubMethod)
.AppendParameters(method.SubMethodParameters, method.SubMethodBase != null);
if (method.IsLambda)
{
builder.Append(" => { }");
if (method.Ordinal.HasValue)
{
builder.Append(" [");
builder.Append(method.Ordinal);
builder.Append("]");
}
}
}
}
protected override Entity InternalResolve <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Reference reference)
{
var real = (LocalVariableReference)reference;
var exists = method.Variables.TryGetValue(real.Index, out var resolved);
Trace.Assert(exists);
if (!exists)
{
method.AddLocalVariable(new ResolvedLocalVariable(real.Index));
resolved = method.Variables[real.Index];
}
if (resolved.DefaultClassType < 0 && real.DefaultType != null)
{
var defaultType = program.GetOrCreateClass(real.DefaultType);
resolved.DefaultClassType = defaultType.Id.GlobalId;
}
return(resolved);
}
public void ClearMethod(ResolvedMethod <TNode> method)
{
var toRemove = method.Methods.Keys.ToList();
foreach (var localFunction in toRemove)
{
RemoveMethod(method, localFunction);
}
var essential = new[] { method.Start, method.Final };
var toDelete = method.GetOwnedNodes().Except(essential);
foreach (var node in toDelete)
{
RemoveVertex(node);
myOnNodeRemovedHandler(node);
}
RemoveOutEdgeIf(method.Start, _ => true);
RemoveInEdgeIf(method.Final, _ => true);
method.Clear();
}
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);
}
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);
}
protected override Entity InternalResolve <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Reference reference)
{
var classFieldReference = (ClassFieldReference)reference;
if (classFieldReference.Owner is ClassReference classReference)
{
var clazz = program.GetOrCreateClass(classReference.ClassId);
var field = program.GetOrCreateClassField(clazz.Id, classFieldReference.Name);
if (classFieldReference.DefaultClassType != null)
{
field.DefaultClassType = program.GetOrCreateClass(classFieldReference.DefaultClassType).Id.GlobalId;
}
return(field);
}
else if (classFieldReference.Owner is LocalVariableReference localVariableReference)
{
var localVariable = method.Variables[localVariableReference.Index];
var fieldId = program.GetOrCreateFieldId(classFieldReference.Name);
var resolvedObjectField = new ResolvedObjectField(localVariable, fieldId)
{
FindClassField = program.FindClassFieldById
};
method.StoreAdditionalVariable(resolvedObjectField);
return(resolvedObjectField);
}
else if (classFieldReference.Owner is ClassFieldReference anotherReference)
{
var resolvedAnotherReference = (SecondaryEntity)Resolve(program, method, anotherReference);
var fieldId = program.GetOrCreateFieldId(classFieldReference.Name);
var resolvedObjectField = new ResolvedObjectField(resolvedAnotherReference, fieldId)
{
FindClassField = program.FindClassFieldById
};
method.StoreAdditionalVariable(resolvedObjectField);
return(resolvedObjectField);
}
else if (classFieldReference.Owner is ClassPropertyReference propertyReference)
{
var resolvedAnotherReference = (SecondaryEntity)Resolve(program, method, propertyReference);
var fieldId = program.GetOrCreateFieldId(classFieldReference.Name);
var resolvedObjectField = new ResolvedObjectField(resolvedAnotherReference, fieldId)
{
FindClassField = program.FindClassFieldById
};
method.StoreAdditionalVariable(resolvedObjectField);
return(resolvedObjectField);
}
Trace.Assert(false);
return(null);
}
public void Transform(
INodeBasedProgram <int> sourceMethod,
GraphStructuredProgram <TNode> targetProgram,
ResolvedMethod <TNode> targetMethod,
Func <int, TNode> mapper)
{
int counter = -1;
TNode CreateNewNode()
{
var newNode = mapper(counter--);
targetMethod.AddOwnedNode(newNode);
return(newNode);
}
var visited = new HashSet <int>();
var localStarts = sourceMethod.GetStarts();
var queued = new Stack <(TNode source, int target)>();
foreach (var localStart in localStarts)
{
queued.Push((targetMethod.Start, localStart));
}
if (queued.Count == 0)
{
targetProgram.AddOperation(targetMethod.Start, new Operation <TNode>(myNop, targetMethod.Final));
}
while (queued.Count > 0)
{
var(source, rawTarget) = queued.Pop();
var statement = sourceMethod.StatementAt(rawTarget);
var target = mapper(rawTarget);
InternalStep(targetProgram, targetMethod, source, statement, target, CreateNewNode);
if (visited.Contains(rawTarget))
{
continue;
}
if (sourceMethod.IsFinal(rawTarget))
{
targetProgram.AddOperation(target, new Operation <TNode>(myReturn, targetMethod.Final));
}
else
{
var transitions = sourceMethod.Transitions(rawTarget).ToList();
foreach (var transition in transitions)
{
queued.Push((target, transition));
}
}
visited.Add(rawTarget);
}
}
protected abstract Entity InternalResolve <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Reference reference);
protected abstract Entity RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Entity entity);
private static ResolvedMethod GetMethodDisplay(MethodBase originMethod)
{
var methodDisplayInfo = new ResolvedMethod();
// Special case: no method available
if (originMethod == null)
{
return(methodDisplayInfo);
}
var method = originMethod;
methodDisplayInfo.SubMethodBase = method;
// Type name
var type = method.DeclaringType;
var subMethodName = method.Name;
var methodName = method.Name;
if (type != null && type.IsDefined(typeof(CompilerGeneratedAttribute)) &&
(typeof(IAsyncStateMachine).IsAssignableFrom(type) || typeof(IEnumerator).IsAssignableFrom(type)))
{
methodDisplayInfo.IsAsync = typeof(IAsyncStateMachine).IsAssignableFrom(type);
// Convert StateMachine methods to correct overload +MoveNext()
if (!TryResolveStateMachineMethod(ref method, out type))
{
methodDisplayInfo.SubMethodBase = null;
subMethodName = null;
}
methodName = method.Name;
}
// Method name
methodDisplayInfo.MethodBase = method;
methodDisplayInfo.Name = methodName;
if (method.Name.IndexOf("<", StringComparison.Ordinal) >= 0)
{
if (TryResolveGeneratedName(ref method, out type, out methodName, out subMethodName, out var kind, out var ordinal))
{
methodName = method.Name;
methodDisplayInfo.MethodBase = method;
methodDisplayInfo.Name = methodName;
methodDisplayInfo.Ordinal = ordinal;
}
else
{
methodDisplayInfo.MethodBase = null;
}
methodDisplayInfo.IsLambda = (kind == GeneratedNameKind.LambdaMethod);
if (methodDisplayInfo.IsLambda && type != null)
{
if (methodName == ".cctor")
{
var fields = type.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
foreach (var field in fields)
{
var value = field.GetValue(field);
if (value is Delegate d)
{
if (ReferenceEquals(d.Method, originMethod) && d.Target.ToString() == originMethod.DeclaringType?.ToString())
{
methodDisplayInfo.Name = field.Name;
methodDisplayInfo.IsLambda = false;
method = originMethod;
break;
}
}
}
}
}
}
protected abstract InternalStatement RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
InternalStatement statement);