public MemberReference GetMemberReference(IAssemblyResolver resolver)
{
if (resolver == null)
throw new ArgumentNullException("resolver");
if (memberReference != null)
return memberReference;
// reload from filename
ReaderParameters readerParameters = new ReaderParameters();
// Use new assembly resolver instance so that the AssemblyDefinitions can be garbage-collected
// once the code is decompiled.
readerParameters.AssemblyResolver = resolver;
string typeName;
if (GetAssemblyAndType(FileName.ToString(), out assemblyFile, out typeName)) {
ModuleDefinition module = ModuleDefinition.ReadModule(assemblyFile, readerParameters);
TypeDefinition typeDefinition = module.GetType(typeName);
if (typeDefinition == null)
throw new InvalidOperationException("Could not find type");
memberReference = typeDefinition;
}
return memberReference;
}
public TestDescriptor GetTestDescriptorFor(MemberReference refer)
{
var reference = refer as MethodReference;
if (reference == null) return null;
if (!IsTest(reference)) return null;
return new TestDescriptor(reference.Name, reference.Module.FullyQualifiedName, "simple.testing", reference.DeclaringType.FullName);
}
internal BfMember(BfCache cache, MemberReference memberRef, BfType type)
{
this._name = memberRef.Name;
this._fullName = type.FullName + "." + this._name;
this._cache = cache;
this._type = type;
}
public Dictionary<string, GenericEntry> GetGenericContextOf(MemberReference memberReference)
{
var ret = new Dictionary<string, GenericEntry>();
GetMethodGenericArgumentsOn(memberReference, ret);
GetClassGenericArgumentsOn(memberReference, ret);
return ret;
}
public AnalysisNet.Types.IMetadataReference ExtractToken(Cecil.MemberReference token)
{
AnalysisNet.Types.IMetadataReference result = AnalysisNet.Types.PlatformType.Unknown;
if (token is Cecil.MethodReference methodRef)
{
result = ExtractMethod(methodRef);
}
else if (token is Cecil.TypeReference typeRef)
{
result = ExtractType(typeRef);
}
else if (token is Cecil.FieldReference fieldRef)
{
// not sure about it
bool isStatic = fieldRef.IsDefinition ? fieldRef.Resolve().IsStatic : true;
result = ExtractField(fieldRef, isStatic);
}
else
{
throw new NotImplementedException();
}
return(result);
}
public static void Analyze(MemberReference member)
{
if (member is TypeReference) {
TypeDefinition type = ((TypeReference)member).Resolve();
if (type != null)
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedTypeTreeNode(type));
}
else if (member is FieldReference) {
FieldDefinition field = ((FieldReference)member).Resolve();
if (field != null)
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedFieldTreeNode(field));
}
else if (member is MethodReference) {
MethodDefinition method = ((MethodReference)member).Resolve();
if (method != null)
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedMethodTreeNode(method));
}
else if (member is PropertyReference) {
PropertyDefinition property = ((PropertyReference)member).Resolve();
if (property != null)
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedPropertyTreeNode(property));
}
else if (member is EventReference) {
EventDefinition @event = ((EventReference)member).Resolve();
if (@event != null)
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedEventTreeNode(@event));
}
}
public static string GetJsName(MemberReference memberRef)
{
var provider = GetProvider(memberRef);
if (provider == null)
return null;
return GetStringFromAttribute(provider, JsName);
}
public static bool MemberIsHidden(MemberReference member, DecompilerSettings settings)
{
MethodDefinition method = member as MethodDefinition;
if (method != null) {
if (method.IsGetter || method.IsSetter || method.IsAddOn || method.IsRemoveOn)
return true;
if (settings.AnonymousMethods && method.Name.StartsWith("<", StringComparison.Ordinal) && method.IsCompilerGenerated())
return true;
}
TypeDefinition type = member as TypeDefinition;
if (type != null && type.DeclaringType != null) {
if (settings.AnonymousMethods && type.Name.StartsWith("<>c__DisplayClass", StringComparison.Ordinal) && type.IsCompilerGenerated())
return true;
if (settings.YieldReturn && YieldReturnDecompiler.IsCompilerGeneratorEnumerator(type))
return true;
}
FieldDefinition field = member as FieldDefinition;
if (field != null && field.IsCompilerGenerated()) {
if (settings.AnonymousMethods && field.Name.StartsWith("CS$<>", StringComparison.Ordinal))
return true;
if (settings.AutomaticProperties && field.Name.StartsWith("<", StringComparison.Ordinal) && field.Name.EndsWith("BackingField", StringComparison.Ordinal))
return true;
}
// event-fields are not [CompilerGenerated]
if (field != null && settings.AutomaticEvents && field.DeclaringType.Events.Any(ev => ev.Name == field.Name))
return true;
return false;
}
internal static void AssertInstruction(Instruction actual, OpCode opCode, MemberReference expectedCtor)
{
Assert.AreEqual(opCode, actual.OpCode);
MethodReference actualCtor = (MethodReference)actual.Operand;
Assert.AreEqual(expectedCtor.DeclaringType.Name, actualCtor.DeclaringType.Name, opCode.ToString());
Assert.AreEqual(expectedCtor, actualCtor.Resolve(), opCode.ToString());
}
private MethodUsage CreateUsage(MemberReference operand, ModuleDefinition assembly, TypeDefinition type, MethodDefinition method, string testAssemblyPath)
{
if (operand == null)
return null;
Test test = new Test
{
PathToAssembly = Path.GetDirectoryName(testAssemblyPath),
AssemblyName = assembly.Assembly.Name.Name,
NamespaceName = type.Namespace,
ClassName = type.Name,
MethodName = method.Name
};
var instructionCall = new MethodUsage
{
AssemblyName = operand.DeclaringType.Scope.Name + ".dll",
NamespaceName = operand.DeclaringType.Namespace,
ClassName = operand.DeclaringType.Name,
MethodName = operand.Name,
TestCoverage = new List<Test> {test}
};
return instructionCall;
}
/// <summary>
/// Mark all children of the given member
/// </summary>
internal static void Walk(ReachableContext context, MemberReference member)
{
// Mark declaring type
member.DeclaringType.MarkReachable(context);
TypeReference typeRef;
MethodReference methodRef;
EventReference eventRef;
FieldReference fieldRef;
PropertyReference propertyRef;
if ((typeRef = member as TypeReference) != null)
{
Walk(context, typeRef);
}
else if ((methodRef = member as MethodReference) != null)
{
Walk(context, methodRef);
}
else if ((eventRef = member as EventReference) != null)
{
Walk(context, eventRef);
}
else if ((fieldRef = member as FieldReference) != null)
{
Walk(context, fieldRef);
}
else if ((propertyRef = member as PropertyReference) != null)
{
Walk(context, propertyRef);
}
}
public static AnalyzerTreeNode TryCreateAnalyzer(MemberReference member)
{
if (CanShow(member))
return new AnalyzedEventTreeNode(member as EventDefinition);
else
return null;
}
static bool IsStringConcat (MemberReference member)
{
if (member == null || (member.Name != "Concat"))
return false;
return (member.DeclaringType.FullName == "System.String");
}
public static void EnsureWellName(MemberReference r)
{
if (r.mWellName != null) return;
if (IGNORE_WELLNAMING)
{
r.mWellName = r.Name;
return;
}
TypeReference tr = r as TypeReference;
if (tr != null) { CreateWellName(tr); return; }
FieldReference fr = r as FieldReference;
if (fr != null) { CreateWellName(fr); return; }
PropertyReference pr = r as PropertyReference;
if (pr != null) { CreateWellName(pr); return; }
MethodReference mr = r as MethodReference;
if (mr != null) { CreateWellName(mr); return; }
EventReference er = r as EventReference;
if (er != null) { CreateWellName(er); return; }
throw new Exception();
}
public IEnumerable<ExceptionSources> this [MemberReference member] {
get {
if (member == null)
throw new ArgumentNullException ("member");
MemberReference memberDef = member.Resolve ();
if (memberDef == null) {
ArrayType array = member.DeclaringType as ArrayType;
if (array != null && array.Rank > 1) {
// Multi-dimensional array; the member is runtime generated,
// doesn't "really" exist (in a form that we can resolve),
// so we can't do anything further.
return new ExceptionSources[0];
}
throw new NotSupportedException (string.Format (
"Unable to resolve member {0}::{1}.",
member.DeclaringType.FullName, member.Name));
}
string memberDecl = xdoc.GetDeclaration (member.Resolve ());
Dictionary<string, ExceptionSources> e;
if (!db.TryGetValue (memberDecl, out e)) {
e = new Dictionary<string, ExceptionSources> ();
var bodies = GetMethodBodies (member);
foreach (var body in bodies) {
if (body == null)
continue;
FillExceptions (body, e);
}
db.Add (memberDecl, e);
}
return e.Values;
}
}
public void SetIndirectConstraintsOn(MemberReference reference, MemberReference parent, bool inInheritance)
{
if (reference == null) return;
if (parent == null) return;
//TODO handle inInheritance call
var def = reference.DeclaringType.ThreadSafeResolve();
if (def != null && def.IsInterface)
{
//coming back to an interface
var mdp = ((MethodReference)parent).ThreadSafeResolve();
var mdr = ((MethodReference)reference).ThreadSafeResolve();
if (mdp == null || mdr == null) return;
if (mdp.Parameters.Count != mdr.Parameters.Count) Console.WriteLine("not sure what to do?!");
for (var i = 0; i < mdp.Parameters.Count; i++)
{
var current = mdr.Parameters[i].GetTypeWithGenericResolve();
if (current == null) continue; ;
if (current.IsGenericParameter)
{
var par = mdp.Parameters[i].GetTypeWithGenericResolve();
if (par == null) continue;
if(!_limitations.ContainsKey(current.Name))
{
_limitations.Add(current.Name,
par.IsGenericParameter
? new GenericEntry(null, true, par.Name)
: new GenericEntry(par.ThreadSafeResolve(), false, null));
}
}
}
}
}
private static MemberReference GetMatchingElementMethod(MemberReference memberReference)
{
var methodReference = memberReference as MethodReference;
var declaringType = (GenericInstanceType) memberReference.DeclaringType;
var elementType = declaringType.ElementType.ThreadSafeResolve();
if (elementType == null)
return null;
foreach (var current in elementType.Methods)
{
if(current.Name == memberReference.Name &&
current.Parameters.Count == methodReference.Parameters.Count)
{
//TODO need to check out params in cases where there are many matches
//for (int index = 0; index < methodReference.Parameters.Count; index++)
//{
// var method = methodReference.Parameters[index];
// var element = current.Parameters[index];
// var elementtype = element.GetTypeWithGenericResolve();
// var methodtype = method.GetTypeWithGenericResolve();
// if (elementtype == methodtype)
// {
// return current;
// }
//}
return current;
}
}
return null;
}
public BreakpointBookmark(MemberReference member, AstLocation location, ILRange range, BreakpointAction action, DecompiledLanguages language) : base(member, location)
{
this.action = action;
this.ILRange = range;
this.Tooltip = string.Format("Language:{0}, Line:{1}, IL range:{2}-{3}", language.ToString(), location.Line, range.From, range.To);
this.Language = language;
}
/// <summary>
/// Create data in the CodeMappings and DecompiledMemberReferences.
/// </summary>
/// <param name="token">Token of the current method.</param>
/// <param name="member">Current member (MethodDefinition, PropertyDefinition, EventDefinition).</param>
/// <remarks>The token is used in CodeMappings; member (and its token) is used in DecompiledMemberReferences.</remarks>
protected virtual void CreateCodeMappings(int token, MemberReference member)
{
this.CodeMappings.Add(token, new List<MemberMapping>());
int t = member.MetadataToken.ToInt32();
if (!this.DecompiledMemberReferences.ContainsKey(t))
this.DecompiledMemberReferences.Add(t, member);
}
private AnalysisNet.IInstruction ProcessLoadToken(Cecil.Cil.Instruction op)
{
Cecil.MemberReference cciToken = op.Operand as Cecil.MemberReference;
AnalysisNet.Types.IMetadataReference ourToken = typeExtractor.ExtractToken(cciToken);
AnalysisNetBytecode.LoadTokenInstruction instruction = new AnalysisNetBytecode.LoadTokenInstruction((uint)op.Offset, ourToken);
return(instruction);
}
public BreakpointBookmark(MemberReference member, TextLocation location, int functionToken, ILRange range, BreakpointAction action)
: base(member, location)
{
this.action = action;
this.FunctionToken = functionToken;
this.ILRange = range;
this.Tooltip = string.Format("Line:{0}, IL range:{1}-{2}", location.Line, range.From, range.To);
}
private bool ApplyToMember(Pattern matcher, MemberReference member, Action<MemberReference> action)
{
if (matcher.MemberMatcher != null && !_matcher.MatchesWildcard(matcher.MemberMatcher, member.Name))
return false;
action(member);
return true;
}
static bool CheckBooleanMarshalling (IMarshalInfoProvider spec, MemberReference type)
{
// is marshalling information provided
if (spec.MarshalInfo != null)
return true;
// using StartsWith to catch references (ref)
return !type.FullName.StartsWith ("System.Boolean", StringComparison.Ordinal);
}
/// <summary>
/// Should we walk through the member for all children?
/// </summary>
private static bool ShouldWalk(IReachableContext context, MemberReference member)
{
TypeReference typeRef = member as TypeReference;
if (typeRef == null) { return true; }
if (typeRef is GenericParameter) { return true; }
if (typeRef is TypeSpecification) { return true; }
return context.Contains(typeRef);
}
public ResolutionException (MemberReference member)
: base ("Failed to resolve " + member.FullName)
{
if (member == null)
throw new ArgumentNullException ("member");
this.member = member;
}
static bool LookForEvent (MemberReference field, TypeDefinition type)
{
string fname = field.Name;
foreach (EventDefinition evnt in type.Events) {
if (fname == evnt.Name)
return true;
}
return false;
}
public static bool CanShow(MemberReference member)
{
var property = member as EventDefinition;
if (property == null)
return false;
return AnalyzedEventAccessorsTreeNode.CanShow(property)
|| AnalyzedEventOverridesTreeNode.CanShow(property);
}
public Coupling(string to, bool isReadOnly, bool ignoreWalk, bool isSelfCall, FieldReference fieldReference, MemberReference actualReference)
{
To = to;
FieldReference = fieldReference;
IsSelfCall = isSelfCall;
IsReadOnly = isReadOnly;
IgnoreWalk = ignoreWalk;
ActualReference = actualReference;
}
public static bool CanShow(MemberReference member)
{
var property = member as PropertyDefinition;
if (property == null)
return false;
return !MainWindow.Instance.CurrentLanguage.ShowMember(property.GetMethod ?? property.SetMethod)
|| AnalyzedPropertyOverridesTreeNode.CanShow(property);
}
public bool IsTest(MemberReference reference)
{
var refer = reference as MethodReference;
if (refer == null) return false;
var resolved = refer.ThreadSafeResolve();
var resolvedtype = refer.DeclaringType.ThreadSafeResolve();
if (resolved != null && resolvedtype != null && (resolvedtype.IsAbstract || resolved.IsAbstract)) return false;
return refer.HasAttribute("TestMethod");
}
public bool IsTest(MemberReference reference)
{
var refer = reference as MethodReference;
if (refer == null) return false;
var resolved = refer.ThreadSafeResolve();
var resolvedtype = refer.DeclaringType.ThreadSafeResolve();
if (resolved != null && resolvedtype != null && (resolvedtype.IsAbstract || resolved.IsAbstract)) return false;
return CheckSpecificationReturn(resolved.ReturnType.ThreadSafeResolve()) || CheckIEnumerableSpecificationReturn(resolved);
}
private static InstructionCall GetCall(MemberReference operand)
{
var instructionCall = new InstructionCall();
instructionCall.Assembly = operand.DeclaringType.Scope.Name + ".dll";
instructionCall.Namespace = operand.DeclaringType.Namespace;
instructionCall.Class = operand.DeclaringType.Name;
instructionCall.Method = operand.Name;
return instructionCall;
}
private string UnmangleName(Cecil.MemberReference member)
{
int lastIdx = member.Name.IndexOf('`');
if (lastIdx == -1)
{
return(member.Name);
}
string substring = member.Name.Substring(0, lastIdx);
return(substring);
}
public void Add(MemberReference value)
{
List.Add(value);
}
public int IndexOf(MemberReference value)
{
return(List.IndexOf(value));
}
public void Insert(int index, MemberReference value)
{
List.Insert(index, value);
}
public void Remove(MemberReference value)
{
List.Remove(value);
}
public ResolutionException(MemberReference member)
: base("Failed to resolve " + member.FullName)
{
this.member = member;
}
public MemberHandleExpression(Mono.Cecil.MemberReference memberRef, IEnumerable <Instruction> instructions)
{
base(instructions);
this.set_MemberReference(memberRef);
return;
}
public bool Contains(MemberReference value)
{
return(List.Contains(value));
}
private void ResolveMember()
{
var @event = _memberReferenceExpression.Annotation <EventReference>();
if (@event != null)
{
EventInfo eventInfo = null;
_memberReference = @event;
Member = eventInfo = @event.GetActualEvent();
InternalType = eventInfo.EventHandlerType;
_isStatic = false;
return;
}
var field = _memberReferenceExpression.Annotation <FieldReference>();
if (field != null)
{
FieldInfo fieldInfo = null;
_memberReference = field;
Member = fieldInfo = field.GetActualField();
_isStatic = fieldInfo.IsStatic;
InternalType = fieldInfo.FieldType;
return;
}
var property = _memberReferenceExpression.Annotation <PropertyDefinition>();
if (property != null)
{
MethodInfo methodInfo = null;
PropertyInfo propertyInfo = null;
var methodReference = _memberReferenceExpression.Annotation <MethodReference>();
_memberReference = property;
propertyInfo = property.GetActualProperty();
methodInfo = methodReference.GetActualMethod <MethodInfo>();
_isStatic = methodInfo.IsStatic;
if (propertyInfo.CanWrite && propertyInfo.GetSetMethod(true).Equals(methodInfo))
{
Member = propertyInfo;
InternalType = propertyInfo.PropertyType;
}
else
{
Member = methodInfo;
InternalType = methodInfo.ReturnType;
}
return;
}
var method = _memberReferenceExpression.Annotation <MethodReference>() ??
_memberReferenceExpression.Parent.Annotation <MethodReference>();
if (method != null)
{
MethodInfo methodInfo = null;
_memberReference = method;
Member = methodInfo = method.GetActualMethod <MethodInfo>();
_isStatic = methodInfo.IsStatic;
InternalType = methodInfo.ReturnType;
return;
}
var typeInformation = _memberReferenceExpression.Annotation <TypeInformation>();
if (typeInformation != null)
{
MemberInfo[] members = null;
_astExpression = _memberReferenceExpression.Target.AcceptVisitor(Visitor, ParentScope);
members = _astExpression.Type.GetMember(_memberReferenceExpression.MemberName);
if (members.Length > 0)
{
Member = members[0];
}
InternalType = typeInformation.InferredType.GetActualType();
}
}
