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); }
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;