public static AnalyzerTreeNode TryCreateAnalyzer(IMemberRef member)
{
if (CanShow(member))
return new AnalyzedPropertyTreeNode(member as PropertyDef);
else
return null;
}
static IMemberDef ResolveMemberDef(IMemberRef @ref)
{
if (@ref is ITypeDefOrRef)
return ((ITypeDefOrRef)@ref).ResolveTypeDef();
if (@ref is IMethod && ((IMethod)@ref).MethodSig != null) {
var m = (IMethod)@ref;
if (m is MethodSpec)
m = ((MethodSpec)m).Method;
if (m is MemberRef)
return ((MemberRef)m).ResolveMethod();
return m as MethodDef;
}
if (@ref is IField) {
var f = (IField)@ref;
if (f is MemberRef)
return ((MemberRef)f).ResolveField();
return f as FieldDef;
}
if (@ref is PropertyDef)
return (PropertyDef)@ref;
if (@ref is EventDef)
return (EventDef)@ref;
return null;
}
public static AnalyzerTreeNode TryCreateAnalyzer(IMemberRef member)
{
if (CanShow(member))
return new AnalyzedEventTreeNode(member as EventDef);
else
return null;
}
public static bool Write(IDecompilerOutput output, IMemberRef member) {
var method = member as IMethod;
if (method != null && method.IsMethod) {
method.WriteMethodTo(output);
return true;
}
var field = member as IField;
if (field != null && field.IsField) {
field.WriteFieldTo(output);
return true;
}
var prop = member as PropertyDef;
if (prop != null) {
var dis = new ReflectionDisassembler(output, false, new DisassemblerOptions(new System.Threading.CancellationToken(), null));
dis.DisassembleProperty(prop, false);
return true;
}
var evt = member as EventDef;
if (evt != null) {
var dis = new ReflectionDisassembler(output, false, new DisassemblerOptions(new System.Threading.CancellationToken(), null));
dis.DisassembleEvent(evt, false);
return true;
}
var type = member as ITypeDefOrRef;
if (type != null) {
type.WriteTo(output, ILNameSyntax.TypeName);
return true;
}
return false;
}
public BookmarkBase(IMemberRef member, uint ilOffset, TextLocation location, TextLocation endLocation)
{
this.MemberReference = member;
this.ilOffset = ilOffset;
this.Location = location;
this.EndLocation = endLocation;
}
static bool IsPublic(IMemberRef memberRef)
{
var def = Resolve(memberRef);
if (def is TypeDef)
return IsAccessible((TypeDef)def);
var md = def as IMemberDef;
if (md == null)
return false;
if (!IsAccessible(md.DeclaringType))
return false;
var method = def as MethodDef;
if (method != null)
return IsAccessible(method);
var field = def as FieldDef;
if (field != null)
return IsAccessible(field);
var prop = def as PropertyDef;
if (prop != null)
return IsAccessible(prop);
var evt = def as EventDef;
if (evt != null)
return IsAccessible(evt);
return false;
}
string GetDocumentation(XmlDocumentationProvider docProvider, IMemberRef mr) {
var sb = new StringBuilder();
var doc = docProvider.GetDocumentation(XmlDocKeyProvider.GetKey(mr, sb));
if (doc != null)
return doc;
var method = mr as IMethod;
if (method == null)
return null;
string name = method.Name;
if (name.StartsWith("set_") || name.StartsWith("get_")) {
var md = Resolve(method) as MethodDef;
if (md == null)
return null;
mr = md.DeclaringType.Properties.FirstOrDefault(p => p.GetMethod == md || p.SetMethod == md);
return docProvider.GetDocumentation(XmlDocKeyProvider.GetKey(mr, sb));
}
else if (name.StartsWith("add_")) {
var md = Resolve(method) as MethodDef;
if (md == null)
return null;
mr = md.DeclaringType.Events.FirstOrDefault(p => p.AddMethod == md);
return docProvider.GetDocumentation(XmlDocKeyProvider.GetKey(mr, sb));
}
else if (name.StartsWith("remove_")) {
var md = Resolve(method) as MethodDef;
if (md == null)
return null;
mr = md.DeclaringType.Events.FirstOrDefault(p => p.RemoveMethod == md);
return docProvider.GetDocumentation(XmlDocKeyProvider.GetKey(mr, sb));
}
return null;
}
public static string GetKey(IMemberRef member)
{
if (member == null)
return null;
StringBuilder b = new StringBuilder();
if (member is ITypeDefOrRef) {
b.Append("T:");
AppendTypeName(b, ((ITypeDefOrRef)member).ToTypeSig());
}
else {
if (member.IsField)
b.Append("F:");
else if (member.IsPropertyDef)
b.Append("P:");
else if (member.IsEventDef)
b.Append("E:");
else if (member.IsMethod)
b.Append("M:");
AppendTypeName(b, member.DeclaringType.ToTypeSig());
b.Append('.');
b.Append(member.Name.Replace('.', '#'));
IList<Parameter> parameters;
TypeSig explicitReturnType = null;
if (member.IsPropertyDef) {
parameters = GetParameters((PropertyDef)member).ToList();
}
else if (member.IsMethod) {
var mr = (IMethod)member;
if (mr.NumberOfGenericParameters > 0) {
b.Append("``");
b.Append(mr.NumberOfGenericParameters);
}
parameters = mr.GetParameters();
if (mr.Name == "op_Implicit" || mr.Name == "op_Explicit") {
explicitReturnType = mr.MethodSig.GetRetType();
}
}
else {
parameters = null;
}
if (parameters != null && parameters.Any(a => a.IsNormalMethodParameter)) {
b.Append('(');
for (int i = 0; i < parameters.Count; i++) {
var param = parameters[i];
if (!param.IsNormalMethodParameter)
continue;
if (param.MethodSigIndex > 0)
b.Append(',');
AppendTypeName(b, param.Type);
}
b.Append(')');
}
if (explicitReturnType != null) {
b.Append('~');
AppendTypeName(b, explicitReturnType);
}
}
return b.ToString();
}
public BreakpointBookmark(IMemberRef 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);
}
public static bool CanShow(IMemberRef member) {
var property = member as PropertyDef;
if (property == null)
return false;
return !MainWindow.Instance.CurrentLanguage.ShowMember(property.GetMethod ?? property.SetMethod)
|| AnalyzedPropertyOverridesTreeNode.CanShow(property);
}
public static bool JumpTo(DecompilerTextView textView, IMemberRef mr, MethodKey key, int ilOffset)
{
return MainWindow.Instance.JumpToReference(textView, mr, (success, hasMovedCaret) => {
if (success)
return MoveCaretTo(textView, key, ilOffset);
return false;
});
}
public static bool CanShow(IMemberRef member, ILanguage language) {
var property = member as PropertyDef;
if (property == null)
return false;
return !language.ShowMember(property.GetMethod ?? property.SetMethod)
|| PropertyOverridesNode.CanShow(property);
}
public BreakpointBookmark(IMemberRef member, TextLocation location, TextLocation endLocation, ILRange range, bool isEnabled = true)
: base(member, range.From, location, endLocation)
{
var key = MethodKey.Create(member);
Debug.Assert(key != null, "Caller must verify that MethodKey.Create() won't fail");
this.MethodKey = key.Value;
this.ILRange = range;
this.isEnabled = isEnabled;
}
public static bool CanAnalyze(IMemberRef member)
{
member = MainWindow.ResolveReference(member);
return member is TypeDef ||
member is FieldDef ||
member is MethodDef ||
AnalyzedPropertyTreeNode.CanShow(member) ||
AnalyzedEventTreeNode.CanShow(member);
}
public static bool CanShow(IMemberRef member)
{
var eventDef = member as EventDef;
if (eventDef == null)
return false;
return !MainWindow.Instance.CurrentLanguage.ShowMember(eventDef.AddMethod ?? eventDef.RemoveMethod)
|| AnalyzedEventOverridesTreeNode.CanShow(eventDef);
}
static IMemberRef Resolve(IMemberRef mr) {
if (mr is ITypeDefOrRef)
return ((ITypeDefOrRef)mr).ResolveTypeDef();
if (mr is IMethod && ((IMethod)mr).IsMethod)
return ((IMethod)mr).ResolveMethodDef();
if (mr is IField)
return ((IField)mr).ResolveFieldDef();
Debug.Assert(mr is PropertyDef || mr is EventDef || mr is GenericParam, "Unknown IMemberRef");
return null;
}
public static bool JumpToReference(DecompilerTextView textView, IMemberRef mr, Func<TextLocation> getLocation)
{
bool retVal = MainWindow.Instance.JumpToReference(textView, mr, getLocation);
if (!retVal) {
MainWindow.Instance.ShowMessageBox(
string.Format("Could not find {0}\n" +
"Make sure that it's visible in the treeview and not a hidden method or part of a hidden class. You could also try to debug the method in IL mode.", mr));
}
return retVal;
}
static bool IsPublic(IMemberRef memberRef)
{
var def = Resolve(memberRef);
if (def is TypeDef)
{
return(IsAccessible((TypeDef)def));
}
var md = def as IMemberDef;
if (md == null)
{
return(false);
}
if (!IsAccessible(md.DeclaringType))
{
return(false);
}
var method = def as MethodDef;
if (method != null)
{
return(IsAccessible(method));
}
var field = def as FieldDef;
if (field != null)
{
return(IsAccessible(field));
}
var prop = def as PropertyDef;
if (prop != null)
{
return(IsAccessible(prop));
}
var evt = def as EventDef;
if (evt != null)
{
return(IsAccessible(evt));
}
return(false);
}
public void WriteToken(string token, TextTokenKind tokenKind)
{
// Attach member reference to token only if there's no identifier in the current node.
IMemberRef memberRef = GetCurrentMemberReference();
if (memberRef != null && nodeStack.Peek().GetChildByRole(AstNode.Roles.Identifier).IsNull)
{
output.WriteReference(token, memberRef, tokenKind);
}
else
{
output.Write(token, tokenKind);
}
}
public void WriteKeyword(string keyword)
{
IMemberRef memberRef = GetCurrentMemberReference();
var node = nodeStack.Peek();
if (memberRef != null && node is PrimitiveType)
{
output.WriteReference(keyword, memberRef, TextTokenType.Keyword);
}
else
{
output.Write(keyword, TextTokenType.Keyword);
}
}
internal static bool ShowMember(IMemberRef member, bool showAllMembers, DecompilerSettings settings)
{
if (showAllMembers)
{
return(true);
}
var md = member as MethodDef;
if (md != null && (md.IsGetter || md.IsSetter || md.IsAddOn || md.IsRemoveOn))
{
return(true);
}
return(!AstBuilder.MemberIsHidden(member, settings));
}
static IEnumerable<string> GetXmlDocComments(IMemberRef mr)
{
if (mr == null || mr.Module == null)
yield break;
var xmldoc = XmlDocLoader.LoadDocumentation(mr.Module);
if (xmldoc == null)
yield break;
string doc = xmldoc.GetDocumentation(XmlDocKeyProvider.GetKey(mr));
if (doc == null)
yield break;
foreach (var line in AddXmlDocTransform.GetXmlDocLines(new StringReader(doc)))
yield return line;
}
string?GetDocumentation(XmlDocumentationProvider docProvider, IMemberRef mr)
{
var sb = new StringBuilder();
var doc = docProvider.GetDocumentation(XmlDocKeyProvider.GetKey(mr, sb));
if (doc is not null)
{
return(doc);
}
var method = mr as IMethod;
if (method is null)
{
return(null);
}
string name = method.Name;
if (name.StartsWith("set_") || name.StartsWith("get_"))
{
var md = Resolve(method) as MethodDef;
if (md is null)
{
return(null);
}
var mr2 = md.DeclaringType.Properties.FirstOrDefault(p => p.GetMethod == md || p.SetMethod == md);
return(docProvider.GetDocumentation(XmlDocKeyProvider.GetKey(mr2, sb)));
}
else if (name.StartsWith("add_"))
{
var md = Resolve(method) as MethodDef;
if (md is null)
{
return(null);
}
var mr2 = md.DeclaringType.Events.FirstOrDefault(p => p.AddMethod == md);
return(docProvider.GetDocumentation(XmlDocKeyProvider.GetKey(mr2, sb)));
}
else if (name.StartsWith("remove_"))
{
var md = Resolve(method) as MethodDef;
if (md is null)
{
return(null);
}
var mr2 = md.DeclaringType.Events.FirstOrDefault(p => p.RemoveMethod == md);
return(docProvider.GetDocumentation(XmlDocKeyProvider.GetKey(mr2, sb)));
}
return(null);
}
static bool TryGetCAWrite(IHasCustomAttribute hca, IMemberRef member, bool isField, [NotNullWhen(true)] out CustomAttribute?customAttribute)
{
customAttribute = null;
TypeSig?memberType;
if (isField)
{
memberType = ((IField)member).FieldSig?.GetFieldType();
}
else
{
var property = (PropertyDef)member;
var propSig = property.PropertySig;
if (propSig is null || propSig.Params.Count != 0)
{
return(false);
}
memberType = propSig?.GetRetType();
}
foreach (var ca in hca.GetCustomAttributes())
{
if (!new SigComparer().Equals(ca.AttributeType.GetScopeType(), member.DeclaringType))
{
continue;
}
var namedArgs = ca.NamedArguments;
for (int i = 0; i < namedArgs.Count; i++)
{
var namedArg = namedArgs[i];
if (namedArg.IsField != isField)
{
continue;
}
if (namedArg.Name != member.Name)
{
continue;
}
if (!new SigComparer().Equals(namedArg.Type, memberType))
{
continue;
}
customAttribute = ca;
return(true);
}
}
return(false);
}
IMemberRef FilterMemberReference(IMemberRef memberRef)
{
if (memberRef == null)
{
return(null);
}
if (context.Settings.AutomaticEvents && memberRef is FieldDef)
{
var field = (FieldDef)memberRef;
return(field.DeclaringType.FindEvent(field.Name) ?? memberRef);
}
return(memberRef);
}
public bool FindNewName(IMemberRef source, out TypeMapping tm, out string newName)
{
newName = null;
if (!Context.MappedTypes.TryGetValue(source.DeclaringType.CreateKey(), out tm))
{
return(false);
}
var nn = GetOrAddNode(tm);
if (nn == null || !nn.MembersByOldName.TryGetValue(source.Name, out var mn))
{
return(false);
}
newName = mn.NewName;
return(true);
}
void ProcessMemberRef(ConfuserContext context, INameService service, ModuleDefMD module, IMemberRef r) {
var memberRef = r as MemberRef;
if (r is MethodSpec)
memberRef = ((MethodSpec)r).Method as MemberRef;
if (memberRef != null) {
if (memberRef.DeclaringType.TryGetArraySig() != null)
return;
TypeDef declType = memberRef.DeclaringType.ResolveTypeDefThrow();
if (declType.Module != module && context.Modules.Contains((ModuleDefMD)declType.Module)) {
var memberDef = (IDnlibDef)declType.ResolveThrow(memberRef);
service.AddReference(memberDef, new MemberRefReference(memberRef, memberDef));
}
}
}
static IMemberDef ResolveDef(IMemberRef mr)
{
if (mr is ITypeDefOrRef)
{
return(((ITypeDefOrRef)mr).ResolveTypeDef());
}
if (mr is IMethod && ((IMethod)mr).IsMethod)
{
return(((IMethod)mr).ResolveMethodDef());
}
if (mr is IField)
{
return(((IField)mr).ResolveFieldDef());
}
return(mr as IMemberDef);
}
public static bool Write(ITextOutput output, IMemberRef member)
{
var method = member as IMethod;
if (method != null && method.IsMethod)
{
method.WriteMethodTo(output);
return(true);
}
var field = member as IField;
if (field != null && field.IsField)
{
field.WriteFieldTo(output);
return(true);
}
var prop = member as PropertyDef;
if (prop != null)
{
var dis = new ReflectionDisassembler(output, false, new DisassemblerOptions(new System.Threading.CancellationToken(), null));
dis.DisassembleProperty(prop, false);
return(true);
}
var evt = member as EventDef;
if (evt != null)
{
var dis = new ReflectionDisassembler(output, false, new DisassemblerOptions(new System.Threading.CancellationToken(), null));
dis.DisassembleEvent(evt, false);
return(true);
}
var type = member as ITypeDefOrRef;
if (type != null)
{
type.WriteTo(output, ILNameSyntax.TypeName);
return(true);
}
return(false);
}
static IMemberRef Resolve(IMemberRef memberRef)
{
if (memberRef is ITypeDefOrRef)
{
return(((ITypeDefOrRef)memberRef).ResolveTypeDef());
}
if (memberRef is IMethod && ((IMethod)memberRef).IsMethod)
{
return(((IMethod)memberRef).ResolveMethodDef());
}
if (memberRef is IField)
{
return(((IField)memberRef).ResolveFieldDef());
}
Debug.Assert(memberRef is PropertyDef || memberRef is EventDef || memberRef is GenericParam, "Unknown IMemberRef");
return(null);
}
public static void Analyze(IMemberRef member)
{
TypeDef type = null;
if (member is ITypeDefOrRef)
{
type = ((ITypeDefOrRef)member).ResolveTypeDef();
}
if (type != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedTypeTreeNode(type));
}
FieldDef field = member as FieldDef;
if (field == null && member is IField && ((IField)member).IsField)
{
field = ((IField)member).ResolveFieldDef();
}
if (field != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedFieldTreeNode(field));
}
MethodDef method = member as MethodDef;
if (method == null && member is IMethod && ((IMethod)member).IsMethod)
{
method = ((IMethod)member).ResolveMethodDef();
}
if (method != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedMethodTreeNode(method));
}
var propertyAnalyzer = AnalyzedPropertyTreeNode.TryCreateAnalyzer(member);
if (propertyAnalyzer != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(propertyAnalyzer);
}
var eventAnalyzer = AnalyzedEventTreeNode.TryCreateAnalyzer(member);
if (eventAnalyzer != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(eventAnalyzer);
}
}
public static string GetMyFullName(IMemberRef mref)
{
//DeobfuscatorBase.cs
var oldFullName = mref.FullName;
bool ispublic = true;
var fd = mref as dnlib.DotNet.FieldDef;
if (fd != null)
{
ispublic = fd.IsPublic || fd.IsFamily || fd.IsFamilyOrAssembly || fd.IsFamilyAndAssembly;
}
var md = mref as dnlib.DotNet.MethodDef;
if (md != null)
{
ispublic = md.IsPublic || md.IsFamily || md.IsFamilyOrAssembly || md.IsFamilyAndAssembly;
}
TypeDef dt = mref as TypeDef;
if (dt == null)
{
dt = mref.DeclaringType as TypeDef;
}
while ((dt != null) && ispublic)
{
ispublic = dt.IsPublic || dt.IsNestedPublic;
dt = dt.DeclaringType;
}
if (mref is AssemblyDef || mref is EventDef || mref is FileDef)
{
ispublic = true;
}
if (ispublic)
{
oldFullName += "[Public]";
}
return(oldFullName);
}
public override string GetTooltip(IMemberRef member)
{
MethodDef md = member as MethodDef;
PropertyDef pd = member as PropertyDef;
EventDef ed = member as EventDef;
FieldDef fd = member as FieldDef;
if (md != null || pd != null || ed != null || fd != null)
{
AstBuilder b = new AstBuilder(new DecompilerContext(member.Module)
{
Settings = new DecompilerSettings {
UsingDeclarations = false
}
});
b.DecompileMethodBodies = false;
if (md != null)
{
b.AddMethod(md);
}
else if (pd != null)
{
b.AddProperty(pd);
}
else if (ed != null)
{
b.AddEvent(ed);
}
else
{
b.AddField(fd);
}
b.RunTransformations();
foreach (var attribute in b.SyntaxTree.Descendants.OfType <AttributeSection>())
{
attribute.Remove();
}
StringWriter w = new StringWriter();
b.GenerateCode(new PlainTextOutput(w));
return(Regex.Replace(w.ToString(), @"\s+", " ").TrimEnd());
}
return(base.GetTooltip(member));
}
internal override void PopulateValue(IMemberRef target, int optionId, IArgumentList args)
{
if (!args.HasArg(optionId))
{
return;
}
var values = args.GetAllArgValues(optionId);
if (target.CanWrite)
{
target.SetValue(ConvertCollection(values, target.ValueType));
}
else if (target.CanRead)
{
throw new NotImplementedException();
}
}
IMemberRef GetCurrentMemberReference()
{
AstNode node = nodeStack.Peek();
IMemberRef memberRef = node.Annotation <IMemberRef>();
if (memberRef == null && node.Role == Roles.TargetExpression && (node.Parent is InvocationExpression || node.Parent is ObjectCreateExpression))
{
memberRef = node.Parent.Annotation <IMemberRef>();
}
if (node is IdentifierExpression && node.Role == Roles.TargetExpression && node.Parent is InvocationExpression && memberRef != null)
{
var declaringType = memberRef.DeclaringType.ResolveTypeDef();
if (declaringType != null && declaringType.IsDelegate())
{
return(null);
}
}
return(FilterMemberReference(memberRef));
}
static IMemberDef Resolve(IMemberRef memberRef)
{
var member = MainWindow.ResolveReference(memberRef);
var md = member as MethodDef;
if (md == null)
return member;
if (md.SemanticsAttributes == 0)
return member;
// Find the property or event and return it instead
foreach (var prop in md.DeclaringType.Properties) {
foreach (var md2 in prop.GetMethods) {
if (md2 == md)
return prop;
}
foreach (var md2 in prop.SetMethods) {
if (md2 == md)
return prop;
}
foreach (var md2 in prop.OtherMethods) {
if (md2 == md)
return prop;
}
}
foreach (var evt in md.DeclaringType.Events) {
if (evt.AddMethod == md)
return evt;
if (evt.InvokeMethod == md)
return evt;
if (evt.RemoveMethod == md)
return evt;
foreach (var md2 in evt.OtherMethods) {
if (md2 == md)
return evt;
}
}
// Shouldn't be here
return member;
}
void AddCurrentMember(IMemberRef m)
{
IMemberRef existingMember;
if (currentMembers.TryGetValue(m.Name, out existingMember))
{
// We keep the existing member assignment if it was from another class (=from a derived class),
// because members in derived classes have precedence over members in base classes.
if (existingMember != null && existingMember.DeclaringType == m.DeclaringType)
{
// Use null as value to signalize multiple members with the same name
currentMembers[m.Name] = null;
}
}
else
{
currentMembers.Add(m.Name, m);
}
}
static IMemberDef ResolveMemberDef(IMemberRef @ref)
{
if (@ref is ITypeDefOrRef)
{
return(((ITypeDefOrRef)@ref).ResolveTypeDef());
}
if (@ref is IMethod && ((IMethod)@ref).MethodSig != null)
{
var m = (IMethod)@ref;
if (m is MethodSpec)
{
m = ((MethodSpec)m).Method;
}
if (m is MemberRef)
{
return(((MemberRef)m).ResolveMethod());
}
return(m as MethodDef);
}
if (@ref is IField)
{
var f = (IField)@ref;
if (f is MemberRef)
{
return(((MemberRef)f).ResolveField());
}
return(f as FieldDef);
}
if (@ref is PropertyDef)
{
return((PropertyDef)@ref);
}
if (@ref is EventDef)
{
return((EventDef)@ref);
}
return(null);
}
public static void Analyze(IMemberRef member)
{
TypeDef type = null;
if (member is ITypeDefOrRef)
type = ((ITypeDefOrRef)member).ResolveTypeDef();
if (type != null)
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedTypeTreeNode(type));
FieldDef field = member as FieldDef;
if (field != null)
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedFieldTreeNode(field));
MethodDef method = member as MethodDef;
if (method != null)
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedMethodTreeNode(method));
var propertyAnalyzer = AnalyzedPropertyTreeNode.TryCreateAnalyzer(member);
if (propertyAnalyzer != null)
AnalyzerTreeView.Instance.ShowOrFocus(propertyAnalyzer);
var eventAnalyzer = AnalyzedEventTreeNode.TryCreateAnalyzer(member);
if (eventAnalyzer != null)
AnalyzerTreeView.Instance.ShowOrFocus(eventAnalyzer);
}
internal override void PopulateValue(
IMemberRef target, int optionId, IArgumentList args)
{
if (!args.HasArg(optionId))
{
return;
}
bool allowMultiple =
typeof(ICollection <string>).IsAssignableFrom(target.ValueType) ||
typeof(ICollection).IsAssignableFrom(target.ValueType);
if (allowMultiple)
{
target.SetValue(args.GetAllArgValues(optionId));
}
else
{
target.SetValue(args.GetLastArgValue(optionId));
}
}
public static string GetMyFullName_OLD(IMemberRef mref)
{
var oldFullName = mref.FullName;
var ei = oldFullName.IndexOf(' ');
if (ei > 0)
{
oldFullName = oldFullName.Substring(ei + 1);
}
var dt = mref as TypeDef;
if (dt != null && (!dt.IsPublic) && (!dt.IsNestedPublic))
{
oldFullName += "[NonPublic]";
}
dt = mref.DeclaringType as TypeDef;
if (dt != null && (!dt.IsPublic) && (!dt.IsNestedPublic))
{
oldFullName += "[NonPublic]";
}
var fd = mref as dnlib.DotNet.FieldDef;
if (fd != null && (!fd.IsPublic) && (!fd.IsFamily))
{
oldFullName += "[NonPublic]";
}
var md = mref as dnlib.DotNet.MethodDef;
if (md != null && (!md.IsPublic) && (!md.IsFamily))
{
oldFullName += "[NonPublic]";
}
return(oldFullName);
}
/// <summary>
/// Converts a member signature to a string.
/// This is used for displaying the tooltip on a member reference.
/// </summary>
public virtual void WriteToolTip(ITextOutput output, IMemberRef member, IHasCustomAttribute typeAttributes)
{
if (member is ITypeDefOrRef)
{
TypeToString(output, (ITypeDefOrRef)member, true, typeAttributes);
}
else if (member is GenericParam)
{
var gp = (GenericParam)member;
output.Write(IdentifierEscaper.Escape(gp.Name), TextTokenHelper.GetTextTokenType(gp));
output.WriteSpace();
output.Write("in", TextTokenType.Text);
output.WriteSpace();
WriteToolTip(output, gp.Owner, typeAttributes);
}
else
{
//TODO: This should be escaped but since it contains whitespace, parens, etc,
// we can't pass it to IdentifierEscaper.Escape().
output.Write(member.ToString(), TextTokenHelper.GetTextTokenType(member));
}
}
public static void Analyze(IMemberRef member)
{
var memberDef = MainWindow.ResolveReference(member) as IMemberDef;
var type = memberDef as TypeDef;
if (type != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedTypeTreeNode(type));
}
var field = memberDef as FieldDef;
if (field != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedFieldTreeNode(field));
}
var method = memberDef as MethodDef;
if (method != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedMethodTreeNode(method));
}
var propertyAnalyzer = AnalyzedPropertyTreeNode.TryCreateAnalyzer(member);
if (propertyAnalyzer != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(propertyAnalyzer);
}
var eventAnalyzer = AnalyzedEventTreeNode.TryCreateAnalyzer(member);
if (eventAnalyzer != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(eventAnalyzer);
}
}
void WriteKeyword(string keyword)
{
IMemberRef memberRef = GetCurrentMemberReference();
var node = nodeStack.Peek();
if (node is IndexerDeclaration)
{
memberRef = node.Annotation <PropertyDef>();
}
if (memberRef != null && (node is PrimitiveType || node is ConstructorInitializer || node is BaseReferenceExpression || node is ThisReferenceExpression || node is ObjectCreateExpression || node is AnonymousMethodExpression))
{
output.WriteReference(keyword, memberRef, TextTokenType.Keyword);
}
else if (memberRef != null && node is IndexerDeclaration && keyword == "this")
{
output.WriteDefinition(keyword, memberRef, TextTokenType.Keyword, false);
}
else
{
output.Write(keyword, TextTokenType.Keyword);
}
}
static string GetAddress(IMemberRef memberRef)
{
var member = Resolve(memberRef);
if (member == null)
return string.Empty;
//TODO: This code doesn't work with:
// - generic types, eg. IEnumerable<T>
// - constructors
if (member is MethodDef && ((MethodDef)member).IsConstructor)
member = member.DeclaringType; //TODO: Use declaring type until we can search for constructors
if (member.DeclaringType != null && member.DeclaringType.IsEnum && member is FieldDef && ((FieldDef)member).IsLiteral)
member = member.DeclaringType;
string memberName;
if (member.DeclaringType == null)
memberName = member.FullName;
else
memberName = string.Format("{0}.{1}", member.DeclaringType.FullName, member.Name);
return string.Format(msdnAddress, memberName.Replace('/', '.'));
}
public void WriteToken(string token)
{
// Attach member reference to token only if there's no identifier in the current node.
IMemberRef memberRef = GetCurrentMemberReference();
var node = nodeStack.Peek();
if (memberRef != null && HasNoIdentifier(node))
{
output.WriteReference(token, memberRef);
}
else if (CSharpOutputVisitor.IsKeyword(token, node))
{
output.WriteKeyword(token);
}
else if (node is PrimitiveExpression)
{
output.WriteLiteral(token);
}
else
{
output.Write(token);
}
}
public static void Analyze(IMemberRef member)
{
var memberDef = MainWindow.ResolveReference(member) as IMemberDef;
var type = memberDef as TypeDef;
if (type != null)
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedTypeTreeNode(type));
var field = memberDef as FieldDef;
if (field != null)
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedFieldTreeNode(field));
var method = memberDef as MethodDef;
if (method != null)
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedMethodTreeNode(method));
var propertyAnalyzer = AnalyzedPropertyTreeNode.TryCreateAnalyzer(member);
if (propertyAnalyzer != null)
AnalyzerTreeView.Instance.ShowOrFocus(propertyAnalyzer);
var eventAnalyzer = AnalyzedEventTreeNode.TryCreateAnalyzer(member);
if (eventAnalyzer != null)
AnalyzerTreeView.Instance.ShowOrFocus(eventAnalyzer);
}
object Create(IToolTipContentCreatorContext context, IMemberRef @ref)
{
var creator = context.Create();
var resolvedRef = Resolve(@ref) ?? @ref;
creator.SetImage(resolvedRef);
context.Language.WriteToolTip(creator.Output, @ref, null);
creator.CreateNewOutput();
try {
if (resolvedRef is IMemberDef)
{
var docProvider = XmlDocLoader.LoadDocumentation(resolvedRef.Module);
if (docProvider != null)
{
creator.Output.WriteXmlDoc(GetDocumentation(docProvider, resolvedRef));
}
}
}
catch (XmlException) {
}
return(creator.Create());
}
public static bool Write(IDecompilerOutput output, IMemberRef member)
{
if (member is IMethod method && method.IsMethod)
{
method.WriteMethodTo(output);
return(true);
}
if (member is IField field && field.IsField)
{
field.WriteFieldTo(output);
return(true);
}
if (member is PropertyDef prop)
{
var dis = new ReflectionDisassembler(output, false, new DisassemblerOptions(0, new System.Threading.CancellationToken(), null));
dis.DisassembleProperty(prop, false);
return(true);
}
if (member is EventDef evt)
{
var dis = new ReflectionDisassembler(output, false, new DisassemblerOptions(0, new System.Threading.CancellationToken(), null));
dis.DisassembleEvent(evt, false);
return(true);
}
if (member is ITypeDefOrRef type)
{
type.WriteTo(output, ILNameSyntax.TypeName);
return(true);
}
return(false);
}
object Create(IDocumentViewerToolTipProviderContext context, IMemberRef @ref)
{
var provider = context.Create();
var resolvedRef = Resolve(@ref) ?? @ref;
provider.SetImage(resolvedRef);
context.Decompiler.WriteToolTip(provider.Output, @ref, null);
provider.CreateNewOutput();
try {
if (resolvedRef is IMemberDef)
{
var docProvider = XmlDocLoader.LoadDocumentation(resolvedRef.Module);
if (docProvider is not null)
{
provider.Output.WriteXmlDoc(GetDocumentation(docProvider, resolvedRef));
}
}
}
catch (XmlException) {
}
return(provider.Create());
}
public static void Analyze(IDsToolWindowService toolWindowService, Lazy <IAnalyzerService> analyzerService, IDecompiler decompiler, IMemberRef member)
{
var memberDef = ResolveReference(member);
var type = memberDef as TypeDef;
if (type != null)
{
toolWindowService.Show(AnalyzerToolWindowContent.THE_GUID);
analyzerService.Value.Add(new TypeNode(type));
}
var field = memberDef as FieldDef;
if (field != null)
{
toolWindowService.Show(AnalyzerToolWindowContent.THE_GUID);
analyzerService.Value.Add(new FieldNode(field));
}
var method = memberDef as MethodDef;
if (method != null)
{
toolWindowService.Show(AnalyzerToolWindowContent.THE_GUID);
analyzerService.Value.Add(new MethodNode(method));
}
var propertyAnalyzer = PropertyNode.TryCreateAnalyzer(member, decompiler);
if (propertyAnalyzer != null)
{
toolWindowService.Show(AnalyzerToolWindowContent.THE_GUID);
analyzerService.Value.Add(propertyAnalyzer);
}
var eventAnalyzer = EventNode.TryCreateAnalyzer(member, decompiler);
if (eventAnalyzer != null)
{
toolWindowService.Show(AnalyzerToolWindowContent.THE_GUID);
analyzerService.Value.Add(eventAnalyzer);
}
}
object Create(IToolTipContentCreatorContext context, IMemberRef @ref)
{
var creator = context.Create();
var resolvedRef = Resolve(@ref) ?? @ref;
creator.SetImage(resolvedRef);
context.Language.WriteToolTip(creator.Output, @ref, null);
creator.CreateNewOutput();
try {
if (resolvedRef is IMemberDef) {
var docProvider = XmlDocLoader.LoadDocumentation(resolvedRef.Module);
if (docProvider != null)
creator.Output.WriteXmlDoc(GetDocumentation(docProvider, resolvedRef));
}
}
catch (XmlException) {
}
return creator.Create();
}
public virtual void Write(ITextColorWriter output, IMemberRef member, SimplePrinterFlags flags) => new SimpleCSharpPrinter(output, flags).Write(member);
public override void WriteToolTip(ITextOutput output, IMemberRef member, IHasCustomAttribute typeAttributes)
{
if (!(member is ITypeDefOrRef) && Write(output, member))
return;
base.WriteToolTip(output, member, typeAttributes);
}
public virtual void WriteToolTip(ITextColorWriter output, IMemberRef member, IHasCustomAttribute typeAttributes) => new SimpleCSharpPrinter(output, SimplePrinterFlags.Default).WriteToolTip(member);
protected Ref(IMemberRef memberRef, MTypeDef owner, int index) {
this.memberRef = memberRef;
Owner = owner;
Index = index;
}
public static bool HasCustomAttribute(this IMemberRef member, string attributeTypeName)
{
return(false);
}
static IEnumerable<string> GetXmlDocComments(IMemberRef mr)
{
if (mr == null || mr.Module == null)
yield break;
var xmldoc = XmlDocLoader.LoadDocumentation(mr.Module);
if (xmldoc == null)
yield break;
string doc = xmldoc.GetDocumentation(XmlDocKeyProvider.GetKey(mr));
if (doc == null)
yield break;
foreach (var line in AddXmlDocTransform.GetXmlDocLines(new StringReader(doc)))
yield return line;
}
IMemberRef FilterMemberReference(IMemberRef memberRef)
{
if (memberRef == null)
return null;
if (context.Settings.AutomaticEvents && memberRef is FieldDef) {
var field = (FieldDef)memberRef;
return field.DeclaringType.FindEvent(field.Name) ?? memberRef;
}
return memberRef;
}
public virtual bool ShowMember(IMemberRef member) => true;
