private IEntity FindEntityInRelevantAssemblies(string navigateTo, IEnumerable <LoadedAssembly> relevantAssemblies)
{
ITypeReference typeRef = null;
IMemberReference memberRef = null;
if (navigateTo.StartsWith("T:", StringComparison.Ordinal))
{
typeRef = IdStringProvider.ParseTypeName(navigateTo);
}
else
{
memberRef = IdStringProvider.ParseMemberIdString(navigateTo);
typeRef = memberRef.DeclaringTypeReference;
}
foreach (LoadedAssembly asm in relevantAssemblies.ToList())
{
var module = asm.GetPEFileOrNull();
if (CanResolveTypeInPEFile(module, typeRef, out var typeHandle))
{
ICompilation compilation = typeHandle.Kind == HandleKind.ExportedType
? new DecompilerTypeSystem(module, module.GetAssemblyResolver())
: new SimpleCompilation(module, MinimalCorlib.Instance);
return(memberRef == null
? typeRef.Resolve(new SimpleTypeResolveContext(compilation)) as ITypeDefinition
: (IEntity)memberRef.Resolve(new SimpleTypeResolveContext(compilation)));
}
}
return(null);
}
public IEnumerable<ExceptionSources> this [IMemberReference member] {
get {
if (member == null)
throw new ArgumentNullException ("member");
IMemberReference 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 IMember Resolve(ITypeResolveContext context)
{
IType declaringType = typeReference.Resolve(context);
IMember interfaceMember = interfaceMemberReference.Resolve(context.WithCurrentTypeDefinition(declaringType.GetDefinition()));
if (interfaceMember == null)
{
return(null);
}
IEnumerable <IMember> members;
if (interfaceMember.SymbolKind == SymbolKind.Accessor)
{
members = declaringType.GetAccessors(
m => m.IsExplicitInterfaceImplementation,
GetMemberOptions.IgnoreInheritedMembers);
}
else
{
members = declaringType.GetMembers(
m => m.SymbolKind == interfaceMember.SymbolKind && m.IsExplicitInterfaceImplementation,
GetMemberOptions.IgnoreInheritedMembers);
}
return(members.FirstOrDefault(m => m.ImplementedInterfaceMembers.Count == 1 && interfaceMember.Equals(m.ImplementedInterfaceMembers[0])));
}
public IMember Resolve(ITypeResolveContext context)
{
if (accessorReference.Resolve(context) is IMethod method)
return method.AccessorOwner;
else
return null;
}
public IMember Resolve(ITypeResolveContext context)
{
var memberDefinition = memberDefinitionReference.Resolve(context);
return(memberDefinition.Specialize(
new TypeParameterSubstitution(
classTypeArgumentReferences != null ? classTypeArgumentReferences.Resolve(context) : null,
methodTypeArgumentReferences != null ? methodTypeArgumentReferences.Resolve(context) : null
)
));
}
public IMember Resolve(ITypeResolveContext context)
{
if (accessorReference.Resolve(context) is IMethod method)
{
return(method.AccessorOwner);
}
else
{
return(null);
}
}
public IEnumerable <ExceptionSources> this [IMemberReference member] {
get {
if (member == null)
{
throw new ArgumentNullException("member");
}
IMemberReference 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 ISymbol Resolve(ITypeResolveContext context)
{
IParameterizedMember member = memberReference.Resolve(context) as IParameterizedMember;
if (member != null && index >= 0 && index < member.Parameters.Count)
{
return(member.Parameters[index]);
}
else
{
return(null);
}
}
public IMember Resolve(ITypeResolveContext context)
{
IMethod method = accessorReference.Resolve(context) as IMethod;
if (method != null)
{
return(method.AccessorOwner);
}
else
{
return(null);
}
}
public IMember Resolve(ITypeResolveContext context)
{
IMember interfaceMember = interfaceMemberReference.Resolve(context);
if (interfaceMember == null)
{
return(null);
}
IType type = typeReference.Resolve(context);
var members = type.GetMembers(
m => m.EntityType == interfaceMember.EntityType && m.IsExplicitInterfaceImplementation,
GetMemberOptions.IgnoreInheritedMembers);
return(members.FirstOrDefault(m => m.InterfaceImplementations.Count == 1 && interfaceMember.Equals(m.InterfaceImplementations[0])));
}
public IMember Resolve(ITypeResolveContext context)
{
IType declaringType = typeReference.Resolve(context);
IMember interfaceMember = interfaceMemberReference.Resolve(context.WithCurrentTypeDefinition(declaringType.GetDefinition()));
if (interfaceMember == null)
{
return(null);
}
var members = declaringType.GetMembers(
m => m.EntityType == interfaceMember.EntityType && m.IsExplicitInterfaceImplementation,
GetMemberOptions.IgnoreInheritedMembers);
return(members.FirstOrDefault(m => m.ImplementedInterfaceMembers.Count == 1 && interfaceMember.Equals(m.ImplementedInterfaceMembers[0])));
}
public IMember Resolve(ITypeResolveContext context)
{
var declaringType = declaringTypeReference.Resolve(context);
var memberDefinition = memberDefinitionReference.Resolve(context);
IType[] typeArguments = null;
if (typeArgumentReferences != null)
{
typeArguments = new IType[typeArgumentReferences.Count];
for (int i = 0; i < typeArguments.Length; i++)
{
typeArguments[i] = typeArgumentReferences[i].Resolve(context);
}
}
return(CreateSpecializedMember(declaringType, memberDefinition, typeArguments));
}
void HandleCommandLineArgumentsAfterShowList(CommandLineArguments args)
{
if (nugetPackagesToLoad.Count > 0)
{
LoadAssemblies(nugetPackagesToLoad, commandLineLoadedAssemblies, focusNode: false);
nugetPackagesToLoad.Clear();
}
if (args.NavigateTo != null)
{
bool found = false;
if (args.NavigateTo.StartsWith("N:", StringComparison.Ordinal))
{
string namespaceName = args.NavigateTo.Substring(2);
foreach (LoadedAssembly asm in commandLineLoadedAssemblies)
{
AssemblyTreeNode asmNode = assemblyListTreeNode.FindAssemblyNode(asm);
if (asmNode != null)
{
NamespaceTreeNode nsNode = asmNode.FindNamespaceNode(namespaceName);
if (nsNode != null)
{
found = true;
SelectNode(nsNode);
break;
}
}
}
}
else
{
ITypeReference typeRef = null;
IMemberReference memberRef = null;
if (args.NavigateTo.StartsWith("T:", StringComparison.Ordinal))
{
typeRef = IdStringProvider.ParseTypeName(args.NavigateTo);
}
else
{
memberRef = IdStringProvider.ParseMemberIdString(args.NavigateTo);
typeRef = memberRef.DeclaringTypeReference;
}
foreach (LoadedAssembly asm in commandLineLoadedAssemblies)
{
var module = asm.GetPEFileOrNull();
if (CanResolveTypeInPEFile(module, typeRef, out var typeHandle))
{
IEntity mr = null;
ICompilation compilation = typeHandle.Kind == HandleKind.ExportedType
? new DecompilerTypeSystem(module, module.GetAssemblyResolver())
: new SimpleCompilation(module, MinimalCorlib.Instance);
mr = memberRef == null
? typeRef.Resolve(new SimpleTypeResolveContext(compilation)) as ITypeDefinition
: (IEntity)memberRef.Resolve(new SimpleTypeResolveContext(compilation));
if (mr != null && mr.ParentModule.PEFile != null)
{
found = true;
// Defer JumpToReference call to allow an assembly that was loaded while
// resolving a type-forwarder in FindMemberByKey to appear in the assembly list.
Dispatcher.BeginInvoke(new Action(() => JumpToReference(mr)), DispatcherPriority.Loaded);
break;
}
}
}
}
if (!found)
{
AvalonEditTextOutput output = new AvalonEditTextOutput();
output.Write(string.Format("Cannot find '{0}' in command line specified assemblies.", args.NavigateTo));
decompilerTextView.ShowText(output);
}
}
else if (commandLineLoadedAssemblies.Count == 1)
{
// NavigateTo == null and an assembly was given on the command-line:
// Select the newly loaded assembly
JumpToReference(commandLineLoadedAssemblies[0].GetPEFileOrNull());
}
if (args.Search != null)
{
SearchPane.Instance.SearchTerm = args.Search;
SearchPane.Instance.Show();
}
commandLineLoadedAssemblies.Clear(); // clear references once we don't need them anymore
}
public ISymbol Resolve(ITypeResolveContext context)
{
IParameterizedMember member = (IParameterizedMember)memberReference.Resolve(context);
return(member.Parameters[index]);
}
public ISymbol Resolve(ITypeResolveContext context)
{
if (memberReference.Resolve(context) is IParameterizedMember member && index >= 0 && index < member.Parameters.Count)
{
return(member.Parameters[index]);
}
